Prefixed with underscore several internal functions.

18 files changed, 197 insertions, 197 deletions

diff --git a/lib/gnutls_algorithms.c b/lib/gnutls_algorithms.c
index 813dc70cf5..b0cdaed87f 100644
--- a/lib/gnutls_algorithms.c
+++ b/lib/gnutls_algorithms.c
@@ -1060,7 +1060,7 @@ _gnutls_supported_ciphersuites(GNUTLS_STATE state,
 	}
 
 	for (i = j = 0; i < count; i++) {
-		/* remove cipher suites which are not used in the
+		/* remove cipher suites which do not support the
 		 * protocol version used.
 		 */
 		if ( _gnutls_cipher_suite_get_version(tmp_ciphers[i]) > version)
diff --git a/lib/gnutls_cipher.c b/lib/gnutls_cipher.c
index 777d4e91c0..6174875e89 100644
--- a/lib/gnutls_cipher.c
+++ b/lib/gnutls_cipher.c
@@ -171,7 +171,7 @@ int _gnutls_compressed2TLSCiphertext(GNUTLS_STATE state,
 
 	if ( ver == GNUTLS_SSL3) { /* SSL 3.0 */
 		td =
-		    gnutls_mac_init_ssl3(state->security_parameters.
+		    _gnutls_mac_init_ssl3(state->security_parameters.
 					  write_mac_algorithm,
 					  state->connection_state.
 					  write_mac_secret.data,
@@ -179,7 +179,7 @@ int _gnutls_compressed2TLSCiphertext(GNUTLS_STATE state,
 					  write_mac_secret.size);
 	} else { /* TLS 1 */
 		td =
-		    gnutls_hmac_init(state->security_parameters.
+		    _gnutls_hmac_init(state->security_parameters.
 				     write_mac_algorithm,
 				     state->connection_state.
 				     write_mac_secret.data,
@@ -197,19 +197,19 @@ int _gnutls_compressed2TLSCiphertext(GNUTLS_STATE state,
 	    CONVuint64(&state->connection_state.write_sequence_number);
 
 	if (td != GNUTLS_MAC_FAILED) {	/* actually when the algorithm in not the NULL one */
-		gnutls_hmac(td, UINT64DATA(seq_num), 8);
+		_gnutls_hmac(td, UINT64DATA(seq_num), 8);
 		
-		gnutls_hmac(td, &type, 1);
+		_gnutls_hmac(td, &type, 1);
 		if ( ver != GNUTLS_SSL3) { /* TLS 1.0 only */
-			gnutls_hmac(td, &major, 1);
-			gnutls_hmac(td, &minor, 1);
+			_gnutls_hmac(td, &major, 1);
+			_gnutls_hmac(td, &minor, 1);
 		}
-		gnutls_hmac(td, &c_length, 2);
-		gnutls_hmac(td, compressed.data, compressed.size);
+		_gnutls_hmac(td, &c_length, 2);
+		_gnutls_hmac(td, compressed.data, compressed.size);
 		if ( ver == GNUTLS_SSL3) { /* SSL 3.0 */
-			gnutls_mac_deinit_ssl3(td, MAC);
+			_gnutls_mac_deinit_ssl3(td, MAC);
 		} else {
-			gnutls_hmac_deinit(td, MAC);
+			_gnutls_hmac_deinit(td, MAC);
 		}
 	}
 	switch (_gnutls_cipher_is_block(state->security_parameters.write_bulk_cipher_algorithm)) {
@@ -267,7 +267,7 @@ int _gnutls_compressed2TLSCiphertext(GNUTLS_STATE state,
 	memcpy(&data[headers_size], compressed.data, compressed.size);
 	memcpy(&data[compressed.size+headers_size], MAC, hash_size);
 
-	if ( (ret = gnutls_cipher_encrypt(state->connection_state.
+	if ( (ret = _gnutls_cipher_encrypt(state->connection_state.
 			      write_cipher_state, &data[headers_size], 
 			      length)) < 0) {
 		gnutls_free( data);
@@ -306,7 +306,7 @@ int _gnutls_ciphertext2TLSCompressed(GNUTLS_STATE state,
 
 	if ( ver == GNUTLS_SSL3) {
 		td =
-		    gnutls_mac_init_ssl3(state->security_parameters.
+		    _gnutls_mac_init_ssl3(state->security_parameters.
 					  read_mac_algorithm,
 					  state->connection_state.
 					  read_mac_secret.data,
@@ -314,7 +314,7 @@ int _gnutls_ciphertext2TLSCompressed(GNUTLS_STATE state,
 					  read_mac_secret.size);
 	} else {
 		td =
-		    gnutls_hmac_init(state->security_parameters.
+		    _gnutls_hmac_init(state->security_parameters.
 				     read_mac_algorithm,
 				     state->connection_state.
 				     read_mac_secret.data,
@@ -330,7 +330,7 @@ int _gnutls_ciphertext2TLSCompressed(GNUTLS_STATE state,
 
 	switch (_gnutls_cipher_is_block(state->security_parameters.read_bulk_cipher_algorithm)) {
 	case CIPHER_STREAM:
-		if ( (ret = gnutls_cipher_decrypt(state->connection_state.
+		if ( (ret = _gnutls_cipher_decrypt(state->connection_state.
 			      read_cipher_state, ciphertext.data,
 			      ciphertext.size)) < 0) {
 			gnutls_assert();
@@ -348,7 +348,7 @@ int _gnutls_ciphertext2TLSCompressed(GNUTLS_STATE state,
 			return GNUTLS_E_DECRYPTION_FAILED;
 		}
 
-		if ( (ret = gnutls_cipher_decrypt(state->connection_state.
+		if ( (ret = _gnutls_cipher_decrypt(state->connection_state.
 			      read_cipher_state, ciphertext.data,
 			      ciphertext.size)) < 0) {
 			gnutls_assert();
@@ -400,22 +400,22 @@ int _gnutls_ciphertext2TLSCompressed(GNUTLS_STATE state,
 	seq_num = CONVuint64( &state->connection_state.read_sequence_number);
 
 	if (td != GNUTLS_MAC_FAILED) {
-		gnutls_hmac(td, UINT64DATA(seq_num), 8);
+		_gnutls_hmac(td, UINT64DATA(seq_num), 8);
 		
-		gnutls_hmac(td, &type, 1);
+		_gnutls_hmac(td, &type, 1);
 		if ( ver != GNUTLS_SSL3) { /* TLS 1.0 only */
-			gnutls_hmac(td, &major, 1);
-			gnutls_hmac(td, &minor, 1);
+			_gnutls_hmac(td, &major, 1);
+			_gnutls_hmac(td, &minor, 1);
 		}
-		gnutls_hmac(td, &c_length, 2);
+		_gnutls_hmac(td, &c_length, 2);
 		
 		if (data!=NULL)
-			gnutls_hmac(td, data, compress->size);
+			_gnutls_hmac(td, data, compress->size);
 
 		if ( ver == GNUTLS_SSL3) { /* SSL 3.0 */
-			gnutls_mac_deinit_ssl3(td, MAC);
+			_gnutls_mac_deinit_ssl3(td, MAC);
 		} else {
-			gnutls_hmac_deinit(td, MAC);
+			_gnutls_hmac_deinit(td, MAC);
 		}
 	}
 	/* HMAC was not the same. */
diff --git a/lib/gnutls_cipher_int.c b/lib/gnutls_cipher_int.c
index edaf56f844..82d9e27ba1 100644
--- a/lib/gnutls_cipher_int.c
+++ b/lib/gnutls_cipher_int.c
@@ -23,7 +23,7 @@
 #include <gnutls_cipher_int.h>
 #include <gnutls_datum.h>
 
-GNUTLS_CIPHER_HANDLE gnutls_cipher_init( BulkCipherAlgorithm cipher, gnutls_datum key, gnutls_datum iv)
+GNUTLS_CIPHER_HANDLE _gnutls_cipher_init( BulkCipherAlgorithm cipher, gnutls_datum key, gnutls_datum iv)
 {
 GNUTLS_CIPHER_HANDLE ret;
 
@@ -84,7 +84,7 @@ GNUTLS_CIPHER_HANDLE ret;
 return ret;	
 }
 
-int gnutls_cipher_encrypt(GNUTLS_CIPHER_HANDLE handle, void* text, int textlen) {
+int _gnutls_cipher_encrypt(GNUTLS_CIPHER_HANDLE handle, void* text, int textlen) {
 	if (handle!=GNUTLS_CIPHER_FAILED) {
 #ifdef USE_MCRYPT
 		mcrypt_generic( handle, text, textlen);
@@ -98,7 +98,7 @@ int gnutls_cipher_encrypt(GNUTLS_CIPHER_HANDLE handle, void* text, int textlen)
 	return 0;
 }
 
-int gnutls_cipher_decrypt(GNUTLS_CIPHER_HANDLE handle, void* ciphertext, int ciphertextlen) {
+int _gnutls_cipher_decrypt(GNUTLS_CIPHER_HANDLE handle, void* ciphertext, int ciphertextlen) {
 	if (handle!=GNUTLS_CIPHER_FAILED) {
 #ifdef USE_MCRYPT
 		mdecrypt_generic( handle, ciphertext, ciphertextlen);
@@ -112,7 +112,7 @@ int gnutls_cipher_decrypt(GNUTLS_CIPHER_HANDLE handle, void* ciphertext, int cip
 	return 0;
 }
 
-void gnutls_cipher_deinit(GNUTLS_CIPHER_HANDLE handle) {
+void _gnutls_cipher_deinit(GNUTLS_CIPHER_HANDLE handle) {
 	if (handle!=GNUTLS_CIPHER_FAILED) {
 #ifdef USE_MCRYPT
 		mcrypt_generic_end( handle);
diff --git a/lib/gnutls_cipher_int.h b/lib/gnutls_cipher_int.h
index fd6f812d2f..00af5ba064 100644
--- a/lib/gnutls_cipher_int.h
+++ b/lib/gnutls_cipher_int.h
@@ -30,9 +30,9 @@
 # define GNUTLS_CIPHER_FAILED NULL
 #endif
 
-GNUTLS_CIPHER_HANDLE gnutls_cipher_init( BulkCipherAlgorithm cipher, gnutls_datum key, gnutls_datum iv);
-int gnutls_cipher_encrypt(GNUTLS_CIPHER_HANDLE handle, void* text, int textlen);
-int gnutls_cipher_decrypt(GNUTLS_CIPHER_HANDLE handle, void* ciphertext, int ciphertextlen);
-void gnutls_cipher_deinit(GNUTLS_CIPHER_HANDLE handle);
+GNUTLS_CIPHER_HANDLE _gnutls_cipher_init( BulkCipherAlgorithm cipher, gnutls_datum key, gnutls_datum iv);
+int _gnutls_cipher_encrypt(GNUTLS_CIPHER_HANDLE handle, void* text, int textlen);
+int _gnutls_cipher_decrypt(GNUTLS_CIPHER_HANDLE handle, void* ciphertext, int ciphertextlen);
+void _gnutls_cipher_deinit(GNUTLS_CIPHER_HANDLE handle);
 
 #endif /* GNUTLS_CIPHER_INT */
diff --git a/lib/gnutls_compress.c b/lib/gnutls_compress.c
index ff8dedf6de..019a6c35b3 100644
--- a/lib/gnutls_compress.c
+++ b/lib/gnutls_compress.c
@@ -33,7 +33,7 @@ int _gnutls_plaintext2TLSCompressed(GNUTLS_STATE state,
 	
 	data=NULL;
 	
-	size = gnutls_compress( state->connection_state.write_compression_state,
+	size = _gnutls_compress( state->connection_state.write_compression_state,
 		plaintext.data, plaintext.size, &data, MAX_RECORD_SIZE+1024);
 	if (size < 0) {
 		gnutls_assert();
@@ -55,7 +55,7 @@ int _gnutls_TLSCompressed2plaintext(GNUTLS_STATE state,
 
 	data=NULL;
 	
-	size = gnutls_decompress( state->connection_state.read_compression_state,
+	size = _gnutls_decompress( state->connection_state.read_compression_state,
 		compressed.data, compressed.size, &data, MAX_RECORD_SIZE);
 	if (size < 0) {
 		gnutls_assert();
diff --git a/lib/gnutls_compress_int.c b/lib/gnutls_compress_int.c
index 4f2a012d49..38e1dce3e1 100644
--- a/lib/gnutls_compress_int.c
+++ b/lib/gnutls_compress_int.c
@@ -25,7 +25,7 @@
 /* The flag d is the direction (compressed, decompress). Non zero is
  * decompress.
  */
-GNUTLS_COMP_HANDLE gnutls_comp_init( CompressionMethod method, int d)
+GNUTLS_COMP_HANDLE _gnutls_comp_init( CompressionMethod method, int d)
 {
 GNUTLS_COMP_HANDLE ret;
 int err;
@@ -71,7 +71,7 @@ int err;
 	return ret;
 }
 
-void gnutls_comp_deinit(GNUTLS_COMP_HANDLE handle, int d) {
+void _gnutls_comp_deinit(GNUTLS_COMP_HANDLE handle, int d) {
 int err;
 
 	if (handle!=NULL) {
@@ -96,7 +96,7 @@ int err;
 /* These functions are memory consuming 
  */
 
-int gnutls_compress( GNUTLS_COMP_HANDLE handle, char* plain, int plain_size, char** compressed, int max_comp_size) {
+int _gnutls_compress( GNUTLS_COMP_HANDLE handle, char* plain, int plain_size, char** compressed, int max_comp_size) {
 int compressed_size=GNUTLS_E_COMPRESSION_FAILED;
 #ifdef HAVE_LIBZ
 uLongf size;
@@ -150,7 +150,7 @@ int err;
 	return compressed_size;
 }
 
-int gnutls_decompress( GNUTLS_COMP_HANDLE handle, char* compressed, int compressed_size, char** plain, int max_record_size) {
+int _gnutls_decompress( GNUTLS_COMP_HANDLE handle, char* compressed, int compressed_size, char** plain, int max_record_size) {
 int plain_size=GNUTLS_E_DECOMPRESSION_FAILED, err;
 #ifdef HAVE_LIBZ
 uLongf size;
diff --git a/lib/gnutls_compress_int.h b/lib/gnutls_compress_int.h
index 7e5abd4eec..284e6a1479 100644
--- a/lib/gnutls_compress_int.h
+++ b/lib/gnutls_compress_int.h
@@ -32,10 +32,10 @@ typedef struct GNUTLS_COMP_HANDLE_STRUCT {
 	CompressionMethod algo;
 } *GNUTLS_COMP_HANDLE;
 
-GNUTLS_COMP_HANDLE gnutls_comp_init( CompressionMethod, int d);
-void gnutls_comp_deinit(GNUTLS_COMP_HANDLE handle, int d);
+GNUTLS_COMP_HANDLE _gnutls_comp_init( CompressionMethod, int d);
+void _gnutls_comp_deinit(GNUTLS_COMP_HANDLE handle, int d);
 
-int gnutls_decompress( GNUTLS_COMP_HANDLE handle, char* compressed, int compressed_size, char** plain, int max_record_size);
-int gnutls_compress( GNUTLS_COMP_HANDLE, char* plain, int plain_size, char** compressed, int max_comp_size);
+int _gnutls_decompress( GNUTLS_COMP_HANDLE handle, char* compressed, int compressed_size, char** plain, int max_record_size);
+int _gnutls_compress( GNUTLS_COMP_HANDLE, char* plain, int plain_size, char** compressed, int max_comp_size);
 
 #endif
diff --git a/lib/gnutls_constate.c b/lib/gnutls_constate.c
index f31aeda4fa..9c00bddfcb 100644
--- a/lib/gnutls_constate.c
+++ b/lib/gnutls_constate.c
@@ -60,7 +60,7 @@ int _gnutls_set_keys(GNUTLS_STATE state, int hash_size, int IV_size, int key_siz
 	memcpy(&random[TLS_RANDOM_SIZE], state->security_parameters.client_random, TLS_RANDOM_SIZE);
 
 	if ( state->security_parameters.version == GNUTLS_SSL3) { /* SSL 3 */
-		ret = gnutls_ssl3_generate_random( state->security_parameters.master_secret, TLS_MASTER_SIZE, random, 2*TLS_RANDOM_SIZE,
+		ret = _gnutls_ssl3_generate_random( state->security_parameters.master_secret, TLS_MASTER_SIZE, random, 2*TLS_RANDOM_SIZE,
 			block_size, key_block);
 	} else { /* TLS 1.0 */
 		ret =
@@ -280,11 +280,11 @@ int rc;
 		gnutls_sfree_datum( &state->connection_state.read_mac_secret);
 
 	if (state->connection_state.read_cipher_state != NULL)
-		gnutls_cipher_deinit(state->connection_state.
+		_gnutls_cipher_deinit(state->connection_state.
 				     read_cipher_state);
 
 	if (state->connection_state.read_compression_state != NULL)
-		gnutls_comp_deinit(state->connection_state.
+		_gnutls_comp_deinit(state->connection_state.
 				     read_compression_state, 1);
 
 
@@ -299,7 +299,7 @@ int rc;
 		/* initialize cipher state
 		 */
 		state->connection_state.read_cipher_state =
-		    gnutls_cipher_init(state->security_parameters.
+		    _gnutls_cipher_init(state->security_parameters.
 				       read_bulk_cipher_algorithm,
 				       state->cipher_specs.client_write_key,
 				       state->cipher_specs.client_write_IV);
@@ -325,7 +325,7 @@ int rc;
 
 	case GNUTLS_CLIENT:
 		state->connection_state.read_cipher_state =
-		    gnutls_cipher_init(state->security_parameters.
+		    _gnutls_cipher_init(state->security_parameters.
 				       read_bulk_cipher_algorithm,
 				       state->cipher_specs.
 				       server_write_key,
@@ -356,7 +356,7 @@ int rc;
 	}
 
 	state->connection_state.read_compression_state =
-	    gnutls_comp_init(state->security_parameters.
+	    _gnutls_comp_init(state->security_parameters.
 			       read_compression_algorithm, 1);
 
 	if (state->connection_state.read_compression_state ==
@@ -438,11 +438,11 @@ int rc;
 		gnutls_sfree_datum( &state->connection_state.write_mac_secret);
 
 	if (state->connection_state.write_cipher_state != NULL)
-		gnutls_cipher_deinit(state->connection_state.
+		_gnutls_cipher_deinit(state->connection_state.
 				     write_cipher_state);
 
 	if (state->connection_state.write_compression_state != NULL)
-		gnutls_comp_deinit(state->connection_state.
+		_gnutls_comp_deinit(state->connection_state.
 				     write_compression_state, 0);
 
 	mac_size =
@@ -456,7 +456,7 @@ int rc;
 		/* initialize cipher state
 		 */
 		state->connection_state.write_cipher_state =
-		    gnutls_cipher_init(state->security_parameters.write_bulk_cipher_algorithm,
+		    _gnutls_cipher_init(state->security_parameters.write_bulk_cipher_algorithm,
 				       state->cipher_specs.server_write_key,
 				       state->cipher_specs.server_write_IV);
 
@@ -482,7 +482,7 @@ int rc;
 
 	case GNUTLS_CLIENT:
 		state->connection_state.write_cipher_state =
-		    gnutls_cipher_init(state->security_parameters.
+		    _gnutls_cipher_init(state->security_parameters.
 				       write_bulk_cipher_algorithm,
 				       state->cipher_specs.client_write_key,
 				       state->cipher_specs.client_write_IV);
@@ -512,7 +512,7 @@ int rc;
 
 
 	state->connection_state.write_compression_state =
-	    gnutls_comp_init(state->security_parameters.write_compression_algorithm, 0);
+	    _gnutls_comp_init(state->security_parameters.write_compression_algorithm, 0);
 
 	if (state->connection_state.write_compression_state == GNUTLS_COMP_FAILED) {
 		gnutls_assert();
diff --git a/lib/gnutls_handshake.c b/lib/gnutls_handshake.c
index b86d03a25f..809f3d877c 100644
--- a/lib/gnutls_handshake.c
+++ b/lib/gnutls_handshake.c
@@ -59,8 +59,8 @@ int _gnutls_server_select_comp_method(GNUTLS_STATE state,
  */
 inline static
 void _gnutls_handshake_hash_buffers_clear( GNUTLS_STATE state) {
-	gnutls_hash_deinit( state->gnutls_internals.handshake_mac_handle_md5, NULL);
-	gnutls_hash_deinit( state->gnutls_internals.handshake_mac_handle_sha, NULL);
+	_gnutls_hash_deinit( state->gnutls_internals.handshake_mac_handle_md5, NULL);
+	_gnutls_hash_deinit( state->gnutls_internals.handshake_mac_handle_sha, NULL);
 	state->gnutls_internals.handshake_mac_handle_md5 = NULL;
 	state->gnutls_internals.handshake_mac_handle_sha = NULL;
 	_gnutls_handshake_buffer_clear( state);
@@ -134,16 +134,16 @@ static int _gnutls_ssl3_finished(GNUTLS_STATE state, int type, opaque * ret)
 	GNUTLS_MAC_HANDLE td_sha;
 	char *mesg;
 
-	td_md5 = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
+	td_md5 = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
 	if (td_md5 == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	td_sha = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
+	td_sha = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
 	if (td_sha == NULL) {
 		gnutls_assert();
-		gnutls_hash_deinit( td_md5, NULL);
+		_gnutls_hash_deinit( td_md5, NULL);
 		return GNUTLS_E_HASH_FAILED;
 	}
 
@@ -153,11 +153,11 @@ static int _gnutls_ssl3_finished(GNUTLS_STATE state, int type, opaque * ret)
 		mesg = SSL3_CLIENT_MSG;
 	}
 
-	gnutls_hash(td_md5, mesg, siz);
-	gnutls_hash(td_sha, mesg, siz);
+	_gnutls_hash(td_md5, mesg, siz);
+	_gnutls_hash(td_sha, mesg, siz);
 
-	gnutls_mac_deinit_ssl3_handshake(td_md5, ret, state->security_parameters.master_secret, TLS_MASTER_SIZE);
-	gnutls_mac_deinit_ssl3_handshake(td_sha, &ret[16], state->security_parameters.master_secret, TLS_MASTER_SIZE);
+	_gnutls_mac_deinit_ssl3_handshake(td_md5, ret, state->security_parameters.master_secret, TLS_MASTER_SIZE);
+	_gnutls_mac_deinit_ssl3_handshake(td_sha, &ret[16], state->security_parameters.master_secret, TLS_MASTER_SIZE);
 
 	return 0;
 }
@@ -175,22 +175,22 @@ int _gnutls_finished(GNUTLS_STATE state, int type, void *ret)
 	GNUTLS_MAC_HANDLE td_sha;
 
 
-	td_md5 = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
+	td_md5 = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
 	if (td_md5 == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	td_sha = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
+	td_sha = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
 	if (td_sha == NULL) {
 		gnutls_assert();
-		gnutls_hash_deinit( td_md5, NULL);
+		_gnutls_hash_deinit( td_md5, NULL);
 		return GNUTLS_E_HASH_FAILED;
 	}
 
 
-	gnutls_hash_deinit(td_md5, concat);
-	gnutls_hash_deinit(td_sha, &concat[16]);
+	_gnutls_hash_deinit(td_md5, concat);
+	_gnutls_hash_deinit(td_sha, &concat[16]);
 
 	if (type == GNUTLS_SERVER) {
 		mesg = SERVER_MSG;
@@ -377,8 +377,8 @@ char * data;
 	}
 
 	if (siz > 0) {
-		gnutls_hash( state->gnutls_internals.handshake_mac_handle_sha, data, siz);
-		gnutls_hash( state->gnutls_internals.handshake_mac_handle_md5, data, siz);
+		_gnutls_hash( state->gnutls_internals.handshake_mac_handle_sha, data, siz);
+		_gnutls_hash( state->gnutls_internals.handshake_mac_handle_md5, data, siz);
 	}
 	
 	_gnutls_handshake_buffer_empty( state);
@@ -690,8 +690,8 @@ int ret;
 	}
 
 	if ( type != GNUTLS_HELLO_REQUEST) {
-		gnutls_hash( state->gnutls_internals.handshake_mac_handle_sha, dataptr, datalen);
-		gnutls_hash( state->gnutls_internals.handshake_mac_handle_md5, dataptr, datalen);
+		_gnutls_hash( state->gnutls_internals.handshake_mac_handle_sha, dataptr, datalen);
+		_gnutls_hash( state->gnutls_internals.handshake_mac_handle_md5, dataptr, datalen);
 	}
 
 	return 0;
@@ -1783,7 +1783,7 @@ inline
 static int _gnutls_handshake_hash_init( GNUTLS_STATE state) {
 
 	if ( state->gnutls_internals.handshake_mac_handle_md5==NULL) {
-		state->gnutls_internals.handshake_mac_handle_md5 = gnutls_hash_init( GNUTLS_MAC_MD5);
+		state->gnutls_internals.handshake_mac_handle_md5 = _gnutls_hash_init( GNUTLS_MAC_MD5);
 
 		if (state->gnutls_internals.handshake_mac_handle_md5==GNUTLS_HASH_FAILED) {
 			gnutls_assert();
@@ -1792,7 +1792,7 @@ static int _gnutls_handshake_hash_init( GNUTLS_STATE state) {
 	}
 
 	if ( state->gnutls_internals.handshake_mac_handle_sha==NULL) {
-		state->gnutls_internals.handshake_mac_handle_sha = gnutls_hash_init( GNUTLS_MAC_SHA);
+		state->gnutls_internals.handshake_mac_handle_sha = _gnutls_hash_init( GNUTLS_MAC_SHA);
 		if (state->gnutls_internals.handshake_mac_handle_sha==GNUTLS_HASH_FAILED) {
 			gnutls_assert();
 			return GNUTLS_E_MEMORY_ERROR;
diff --git a/lib/gnutls_hash_int.c b/lib/gnutls_hash_int.c
index fcbb0d7ad3..754ba7091a 100644
--- a/lib/gnutls_hash_int.c
+++ b/lib/gnutls_hash_int.c
@@ -27,7 +27,7 @@
  * the gcrypt library that this can be easily changed.
  */
 
-GNUTLS_HASH_HANDLE gnutls_hash_init(MACAlgorithm algorithm)
+GNUTLS_HASH_HANDLE _gnutls_hash_init(MACAlgorithm algorithm)
 {
 	GNUTLS_MAC_HANDLE ret;
 
@@ -69,7 +69,7 @@ GNUTLS_HASH_HANDLE gnutls_hash_init(MACAlgorithm algorithm)
 	return ret;
 }
 
-int gnutls_hash_get_algo_len(MACAlgorithm algorithm)
+int _gnutls_hash_get_algo_len(MACAlgorithm algorithm)
 {
 	int ret;
 
@@ -96,7 +96,7 @@ int gnutls_hash_get_algo_len(MACAlgorithm algorithm)
 
 }
 
-int gnutls_hash(GNUTLS_HASH_HANDLE handle, const void *text, int textlen)
+int _gnutls_hash(GNUTLS_HASH_HANDLE handle, const void *text, int textlen)
 {
 #ifdef USE_MHASH
 	mhash(handle->handle, text, textlen);
@@ -106,7 +106,7 @@ int gnutls_hash(GNUTLS_HASH_HANDLE handle, const void *text, int textlen)
 	return 0;
 }
 
-GNUTLS_HASH_HANDLE gnutls_hash_copy(GNUTLS_HASH_HANDLE handle)
+GNUTLS_HASH_HANDLE _gnutls_hash_copy(GNUTLS_HASH_HANDLE handle)
 {
 GNUTLS_HASH_HANDLE ret;
 
@@ -132,7 +132,7 @@ GNUTLS_HASH_HANDLE ret;
 	return ret;
 }
 
-void gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void* digest)
+void _gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void* digest)
 {
 	char *mac;
 	int maclen;
@@ -155,7 +155,7 @@ void gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void* digest)
 	gcry_md_final(handle->handle);
 	mac = gcry_md_read(handle->handle, 0);
 	if (digest!=NULL)
-		memcpy( digest, mac, gnutls_hash_get_algo_len(handle->algorithm));
+		memcpy( digest, mac, _gnutls_hash_get_algo_len(handle->algorithm));
 
 	gcry_md_close(handle->handle);
 #endif
@@ -164,7 +164,7 @@ void gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void* digest)
 }
 
 
-GNUTLS_MAC_HANDLE gnutls_hmac_init(MACAlgorithm algorithm, void *key,
+GNUTLS_MAC_HANDLE _gnutls_hmac_init(MACAlgorithm algorithm, void *key,
 				   int keylen)
 {
 	GNUTLS_MAC_HANDLE ret;
@@ -215,7 +215,7 @@ GNUTLS_MAC_HANDLE gnutls_hmac_init(MACAlgorithm algorithm, void *key,
 }
 
 
-int gnutls_hmac_get_algo_len(MACAlgorithm algorithm)
+int _gnutls_hmac_get_algo_len(MACAlgorithm algorithm)
 {
 	int ret;
 
@@ -245,7 +245,7 @@ int gnutls_hmac_get_algo_len(MACAlgorithm algorithm)
 
 }
 
-int gnutls_hmac(GNUTLS_MAC_HANDLE handle, const void *text, int textlen)
+int _gnutls_hmac(GNUTLS_MAC_HANDLE handle, const void *text, int textlen)
 {
 
 #ifdef USE_MHASH
@@ -257,7 +257,7 @@ int gnutls_hmac(GNUTLS_MAC_HANDLE handle, const void *text, int textlen)
 
 }
 
-void gnutls_hmac_deinit(GNUTLS_MAC_HANDLE handle, void* digest)
+void _gnutls_hmac_deinit(GNUTLS_MAC_HANDLE handle, void* digest)
 {
 	char *mac;
 	int maclen;
@@ -287,7 +287,7 @@ void gnutls_hmac_deinit(GNUTLS_MAC_HANDLE handle, void* digest)
 	return;
 }
 
-GNUTLS_MAC_HANDLE gnutls_mac_init_ssl3(MACAlgorithm algorithm, void *key,
+GNUTLS_MAC_HANDLE _gnutls_mac_init_ssl3(MACAlgorithm algorithm, void *key,
 					int keylen)
 {
 	GNUTLS_MAC_HANDLE ret;
@@ -307,19 +307,19 @@ GNUTLS_MAC_HANDLE gnutls_mac_init_ssl3(MACAlgorithm algorithm, void *key,
 	if (padsize>0) {
 		memset(ipad, 0x36, padsize);
 	}
-	ret = gnutls_hash_init( algorithm);
+	ret = _gnutls_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);
+		if (keylen > 0) _gnutls_hash(ret, key, keylen);
+		_gnutls_hash(ret, ipad, padsize);
 	}
 
 	return ret;
 }
 
-void gnutls_mac_deinit_ssl3(GNUTLS_MAC_HANDLE handle, void* digest)
+void _gnutls_mac_deinit_ssl3(GNUTLS_MAC_HANDLE handle, void* digest)
 {
 	opaque ret[MAX_HASH_SIZE];
 	GNUTLS_MAC_HANDLE td;
@@ -341,21 +341,21 @@ void gnutls_mac_deinit_ssl3(GNUTLS_MAC_HANDLE handle, void* digest)
 		memset(opad, 0x5C, padsize);
 	}
 
-	td = gnutls_hash_init( handle->algorithm);
+	td = _gnutls_hash_init( handle->algorithm);
 	if (td!=GNUTLS_MAC_FAILED) {
-		if (handle->keysize > 0) gnutls_hash(td, handle->key, handle->keysize);
+		if (handle->keysize > 0) _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);
+		_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);
 
-		gnutls_hash_deinit(td, digest);
+		_gnutls_hash_deinit(td, digest);
 	}
 	return;
 }
 
-void gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle, void* digest, opaque* key, uint32 key_size)
+void _gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle, void* digest, opaque* key, uint32 key_size)
 {
 	opaque ret[MAX_HASH_SIZE];
 	GNUTLS_MAC_HANDLE td;
@@ -379,20 +379,20 @@ void gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle, void* digest, op
 		memset(ipad, 0x36, padsize);
 	}
 
-	td = gnutls_hash_init( handle->algorithm);
+	td = _gnutls_hash_init( handle->algorithm);
 	if (td!=GNUTLS_HASH_FAILED) {
-		if (key_size > 0) gnutls_hash(td, key, key_size);
+		if (key_size > 0) _gnutls_hash(td, key, key_size);
 
-		gnutls_hash(td, opad, padsize);
-		block = gnutls_hmac_get_algo_len(handle->algorithm);
+		_gnutls_hash(td, opad, padsize);
+		block = _gnutls_hmac_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 */
+		if (key_size > 0) _gnutls_hash( handle, key, key_size);
+		_gnutls_hash(handle, ipad, padsize);
+		_gnutls_hash_deinit(handle, ret);	/* get the previous hash */
 
-		gnutls_hash(td, ret, block);
+		_gnutls_hash(td, ret, block);
 
-		gnutls_hash_deinit(td, digest);
+		_gnutls_hash_deinit(td, digest);
 	}
 	return;
 }
@@ -409,17 +409,17 @@ static int ssl3_sha(int i, char *secret, int secret_len, char *random,
 		text1[j] = 65 + i;	/* A==65 */
 	}
 
-	td = gnutls_hash_init(GNUTLS_MAC_SHA);
+	td = _gnutls_hash_init(GNUTLS_MAC_SHA);
 	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, random, random_len);
+	_gnutls_hash(td, text1, i + 1);
+	_gnutls_hash(td, secret, secret_len);
+	_gnutls_hash(td, random, random_len);
 	
-	gnutls_hash_deinit(td, digest);
+	_gnutls_hash_deinit(td, digest);
 	return 0;
 }
 
@@ -430,33 +430,33 @@ static int ssl3_md5(int i, char *secret, int secret_len, char *random,
 	GNUTLS_MAC_HANDLE td;
 	int ret;
 	
-	td = gnutls_hash_init(GNUTLS_MAC_MD5);
+	td = _gnutls_hash_init(GNUTLS_MAC_MD5);
 	if (td == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	gnutls_hash(td, secret, secret_len);
+	_gnutls_hash(td, secret, secret_len);
 
 	ret = ssl3_sha(i, secret, secret_len, random, random_len, tmp);
 	if (ret < 0) {
 		gnutls_assert();
-		gnutls_hash_deinit(td, digest);
+		_gnutls_hash_deinit(td, digest);
 		return ret;
 	}
 
-	gnutls_hash(td, tmp, gnutls_hash_get_algo_len(GNUTLS_MAC_SHA));
+	_gnutls_hash(td, tmp, _gnutls_hash_get_algo_len(GNUTLS_MAC_SHA));
 
-	gnutls_hash_deinit(td, digest);
+	_gnutls_hash_deinit(td, digest);
 	return 0;
 }
 
-int gnutls_ssl3_generate_random(void *secret, int secret_len, void *random,
+int _gnutls_ssl3_generate_random(void *secret, int secret_len, void *random,
 			   int random_len, int bytes, opaque* ret)
 {
 	int size = 0, i = 0;
 	char digest[MAX_HASH_SIZE];
-	int block = gnutls_hash_get_algo_len(GNUTLS_MAC_MD5);
+	int block = _gnutls_hash_get_algo_len(GNUTLS_MAC_MD5);
 	int result;
 
 	while (size < bytes) {
diff --git a/lib/gnutls_hash_int.h b/lib/gnutls_hash_int.h
index 5745ce7c3b..f21b700769 100644
--- a/lib/gnutls_hash_int.h
+++ b/lib/gnutls_hash_int.h
@@ -45,23 +45,23 @@ typedef GNUTLS_MAC_HANDLE GNUTLS_HASH_HANDLE;
 #define GNUTLS_HASH_FAILED NULL
 #define GNUTLS_MAC_FAILED NULL
 
-GNUTLS_MAC_HANDLE gnutls_hmac_init( MACAlgorithm algorithm, void* key, int keylen);
-int gnutls_hmac_get_algo_len(MACAlgorithm algorithm);
-int gnutls_hmac(GNUTLS_MAC_HANDLE handle, const void* text, int textlen);
-void gnutls_hmac_deinit( GNUTLS_MAC_HANDLE handle, void* digest);
+GNUTLS_MAC_HANDLE _gnutls_hmac_init( MACAlgorithm algorithm, void* key, int keylen);
+int _gnutls_hmac_get_algo_len(MACAlgorithm algorithm);
+int _gnutls_hmac(GNUTLS_MAC_HANDLE handle, const void* text, int textlen);
+void _gnutls_hmac_deinit( GNUTLS_MAC_HANDLE handle, void* digest);
 
-GNUTLS_MAC_HANDLE gnutls_mac_init_ssl3( MACAlgorithm algorithm, void* key, int keylen);
-void gnutls_mac_deinit_ssl3( GNUTLS_MAC_HANDLE handle, void* digest);
+GNUTLS_MAC_HANDLE _gnutls_mac_init_ssl3( MACAlgorithm algorithm, void* key, int keylen);
+void _gnutls_mac_deinit_ssl3( GNUTLS_MAC_HANDLE handle, void* digest);
 
-GNUTLS_HASH_HANDLE gnutls_hash_init(MACAlgorithm algorithm);
-int gnutls_hash_get_algo_len(MACAlgorithm algorithm);
-int gnutls_hash(GNUTLS_HASH_HANDLE handle, const void* text, int textlen);
-void gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void* digest);
+GNUTLS_HASH_HANDLE _gnutls_hash_init(MACAlgorithm algorithm);
+int _gnutls_hash_get_algo_len(MACAlgorithm algorithm);
+int _gnutls_hash(GNUTLS_HASH_HANDLE handle, const void* text, int textlen);
+void _gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void* digest);
 
-int gnutls_ssl3_generate_random(void *secret, int secret_len, void *random, int random_len, int bytes, opaque* ret);
+int _gnutls_ssl3_generate_random(void *secret, int secret_len, void *random, int random_len, int bytes, opaque* ret);
 
-void gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle, void* digest, opaque* key, uint32 key_size);
+void _gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle, void* digest, opaque* key, uint32 key_size);
 
-GNUTLS_HASH_HANDLE gnutls_hash_copy(GNUTLS_HASH_HANDLE handle);
+GNUTLS_HASH_HANDLE _gnutls_hash_copy(GNUTLS_HASH_HANDLE handle);
 
 #endif /* GNUTLS_HASH_INT_H */
diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index 4286d58c14..f439491dea 100644
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -33,8 +33,8 @@
 #define HANDSHAKE_DEBUG // Prints some information on handshake 
 #define X509_DEBUG
 #define RECORD_DEBUG
-*/
 #define DEBUG
+*/
 
 /* It might be a good idea to replace int with void*
  * here.
diff --git a/lib/gnutls_kx.c b/lib/gnutls_kx.c
index a37e76bcaa..4ede709cd4 100644
--- a/lib/gnutls_kx.c
+++ b/lib/gnutls_kx.c
@@ -56,7 +56,7 @@ char random[2*TLS_RANDOM_SIZE];
 
 	if ( gnutls_protocol_get_version( state) == GNUTLS_SSL3) {
 		ret =
-		    gnutls_ssl3_generate_random( PREMASTER.data, PREMASTER.size,
+		    _gnutls_ssl3_generate_random( PREMASTER.data, PREMASTER.size,
 			       random, 2*TLS_RANDOM_SIZE, TLS_MASTER_SIZE,
 			       state->security_parameters.master_secret);
 
diff --git a/lib/gnutls_sig.c b/lib/gnutls_sig.c
index 1eae1a8c91..d3d9aa74a1 100644
--- a/lib/gnutls_sig.c
+++ b/lib/gnutls_sig.c
@@ -49,22 +49,22 @@ GNUTLS_MAC_HANDLE td_md5;
 GNUTLS_MAC_HANDLE td_sha;
 
 
-	td_sha = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
+	td_sha = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
 	if (td_sha == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	gnutls_hash_deinit(td_sha, &concat[16]);
+	_gnutls_hash_deinit(td_sha, &concat[16]);
 
 	switch (cert->subject_pk_algorithm) {
 		case GNUTLS_PK_RSA:
-			td_md5 = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
+			td_md5 = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
 			if (td_md5 == NULL) {
 				gnutls_assert();
 				return GNUTLS_E_HASH_FAILED;
 			}
-			gnutls_hash_deinit(td_md5, concat);
+			_gnutls_hash_deinit(td_md5, concat);
 
 			dconcat.data = concat;
 			dconcat.size = 36;
@@ -98,31 +98,31 @@ GNUTLS_MAC_HANDLE td_sha;
 opaque concat[36];
 
 
-	td_sha = gnutls_hash_init( GNUTLS_MAC_SHA);
+	td_sha = _gnutls_hash_init( GNUTLS_MAC_SHA);
 	if (td_sha == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	gnutls_hash( td_sha, state->security_parameters.client_random, TLS_RANDOM_SIZE);
-	gnutls_hash( td_sha, state->security_parameters.server_random, TLS_RANDOM_SIZE);
-	gnutls_hash( td_sha, params->data, params->size);
+	_gnutls_hash( td_sha, state->security_parameters.client_random, TLS_RANDOM_SIZE);
+	_gnutls_hash( td_sha, state->security_parameters.server_random, TLS_RANDOM_SIZE);
+	_gnutls_hash( td_sha, params->data, params->size);
 
-	gnutls_hash_deinit(td_sha, &concat[16]);
+	_gnutls_hash_deinit(td_sha, &concat[16]);
 
 	switch (cert->subject_pk_algorithm) {
 		case GNUTLS_PK_RSA:
-			td_md5 = gnutls_hash_init( GNUTLS_MAC_MD5);
+			td_md5 = _gnutls_hash_init( GNUTLS_MAC_MD5);
 			if (td_md5 == NULL) {
 				gnutls_assert();
 				return GNUTLS_E_HASH_FAILED;
 			}
 
-			gnutls_hash( td_md5, state->security_parameters.client_random, TLS_RANDOM_SIZE);
-			gnutls_hash( td_md5, state->security_parameters.server_random, TLS_RANDOM_SIZE);
-			gnutls_hash( td_md5, params->data, params->size);
+			_gnutls_hash( td_md5, state->security_parameters.client_random, TLS_RANDOM_SIZE);
+			_gnutls_hash( td_md5, state->security_parameters.server_random, TLS_RANDOM_SIZE);
+			_gnutls_hash( td_md5, params->data, params->size);
 
-			gnutls_hash_deinit(td_md5, concat);
+			_gnutls_hash_deinit(td_md5, concat);
 
 			dconcat.data = concat;
 			dconcat.size = 36;
@@ -268,21 +268,21 @@ GNUTLS_MAC_HANDLE td_md5;
 GNUTLS_MAC_HANDLE td_sha;
 gnutls_datum dconcat;
 
-	td_md5 = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
+	td_md5 = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_md5);
 	if (td_md5 == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	td_sha = gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
+	td_sha = _gnutls_hash_copy( state->gnutls_internals.handshake_mac_handle_sha);
 	if (td_sha == NULL) {
 		gnutls_assert();
-		gnutls_hash_deinit( td_md5, NULL);
+		_gnutls_hash_deinit( td_md5, NULL);
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	gnutls_hash_deinit(td_md5, concat);
-	gnutls_hash_deinit(td_sha, &concat[16]);
+	_gnutls_hash_deinit(td_md5, concat);
+	_gnutls_hash_deinit(td_sha, &concat[16]);
 	
 	dconcat.data = concat;
 	dconcat.size = 20+16; /* md5+ sha */
@@ -308,29 +308,29 @@ GNUTLS_MAC_HANDLE td_md5;
 GNUTLS_MAC_HANDLE td_sha;
 opaque concat[36];
 
-	td_md5 = gnutls_hash_init( GNUTLS_MAC_MD5);
+	td_md5 = _gnutls_hash_init( GNUTLS_MAC_MD5);
 	if (td_md5 == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	td_sha = gnutls_hash_init( GNUTLS_MAC_SHA);
+	td_sha = _gnutls_hash_init( GNUTLS_MAC_SHA);
 	if (td_sha == NULL) {
 		gnutls_assert();
-		gnutls_hash_deinit( td_md5, NULL);
+		_gnutls_hash_deinit( td_md5, NULL);
 		return GNUTLS_E_HASH_FAILED;
 	}
 
-	gnutls_hash( td_md5, state->security_parameters.client_random, TLS_RANDOM_SIZE);
-	gnutls_hash( td_md5, state->security_parameters.server_random, TLS_RANDOM_SIZE);
-	gnutls_hash( td_md5, params->data, params->size);
+	_gnutls_hash( td_md5, state->security_parameters.client_random, TLS_RANDOM_SIZE);
+	_gnutls_hash( td_md5, state->security_parameters.server_random, TLS_RANDOM_SIZE);
+	_gnutls_hash( td_md5, params->data, params->size);
 
-	gnutls_hash( td_sha, state->security_parameters.client_random, TLS_RANDOM_SIZE);
-	gnutls_hash( td_sha, state->security_parameters.server_random, TLS_RANDOM_SIZE);
-	gnutls_hash( td_sha, params->data, params->size);
+	_gnutls_hash( td_sha, state->security_parameters.client_random, TLS_RANDOM_SIZE);
+	_gnutls_hash( td_sha, state->security_parameters.server_random, TLS_RANDOM_SIZE);
+	_gnutls_hash( td_sha, params->data, params->size);
 
-	gnutls_hash_deinit(td_md5, concat);
-	gnutls_hash_deinit(td_sha, &concat[16]);
+	_gnutls_hash_deinit(td_md5, concat);
+	_gnutls_hash_deinit(td_sha, &concat[16]);
 
 	dconcat.data = concat;
 	dconcat.size = 36;
diff --git a/lib/gnutls_srp.c b/lib/gnutls_srp.c
index a693319346..0aa59b958f 100644
--- a/lib/gnutls_srp.c
+++ b/lib/gnutls_srp.c
@@ -136,14 +136,14 @@ MPI _gnutls_calc_srp_u(MPI B)
 	_gnutls_mpi_print( b_holder, &b_size, B);
 
 
-	td = gnutls_hash_init(GNUTLS_MAC_SHA);
+	td = _gnutls_hash_init(GNUTLS_MAC_SHA);
 	if (td==NULL) {
 		gnutls_free(b_holder);
 		gnutls_assert();
 		return NULL;
 	}
-	gnutls_hash(td, b_holder, b_size);
-	gnutls_hash_deinit(td, hd);
+	_gnutls_hash(td, b_holder, b_size);
+	_gnutls_hash_deinit(td, hd);
 	
 	memcpy(&u, hd, sizeof(u));
 
@@ -234,25 +234,25 @@ int _gnutls_calc_srp_sha(char *username, char *password, opaque * salt,
 
 	*size = 20;
 
-	td = gnutls_hash_init(GNUTLS_MAC_SHA);
+	td = _gnutls_hash_init(GNUTLS_MAC_SHA);
 	if (td==NULL) {
 		return GNUTLS_E_MEMORY_ERROR;
 	}
-	gnutls_hash(td, username, strlen(username));
-	gnutls_hash(td, ":", 1);
-	gnutls_hash(td, password, strlen(password));
+	_gnutls_hash(td, username, strlen(username));
+	_gnutls_hash(td, ":", 1);
+	_gnutls_hash(td, password, strlen(password));
 	
-	gnutls_hash_deinit(td, res);
+	_gnutls_hash_deinit(td, res);
 
-	td = gnutls_hash_init(GNUTLS_MAC_SHA);
+	td = _gnutls_hash_init(GNUTLS_MAC_SHA);
 	if (td==NULL) {
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	gnutls_hash(td, salt, salt_size);
-	gnutls_hash(td, res, 20);	/* 20 bytes is the output of sha1 */
+	_gnutls_hash(td, salt, salt_size);
+	_gnutls_hash(td, res, 20);	/* 20 bytes is the output of sha1 */
 
-	gnutls_hash_deinit(td, digest);
+	_gnutls_hash_deinit(td, digest);
 
 	return 0;
 }
diff --git a/lib/gnutls_state.c b/lib/gnutls_state.c
index 787f0cbadd..6a47d5fe52 100644
--- a/lib/gnutls_state.c
+++ b/lib/gnutls_state.c
@@ -237,14 +237,14 @@ void gnutls_deinit(GNUTLS_STATE state)
 	gnutls_clear_creds( state);
 
 	if (state->connection_state.read_cipher_state != NULL)
-		gnutls_cipher_deinit(state->connection_state.read_cipher_state);
+		_gnutls_cipher_deinit(state->connection_state.read_cipher_state);
 	if (state->connection_state.write_cipher_state != NULL)
-		gnutls_cipher_deinit(state->connection_state.write_cipher_state);
+		_gnutls_cipher_deinit(state->connection_state.write_cipher_state);
 
 	if (state->connection_state.read_compression_state != NULL)
-		gnutls_comp_deinit(state->connection_state.read_compression_state, 1);
+		_gnutls_comp_deinit(state->connection_state.read_compression_state, 1);
 	if (state->connection_state.write_compression_state != NULL)
-		gnutls_comp_deinit(state->connection_state.write_compression_state, 0);
+		_gnutls_comp_deinit(state->connection_state.write_compression_state, 0);
 
 	gnutls_sfree_datum( &state->cipher_specs.server_write_mac_secret);
 	gnutls_sfree_datum( &state->cipher_specs.client_write_mac_secret);
@@ -432,9 +432,9 @@ static void _gnutls_cal_PRF_A( MACAlgorithm algorithm, void *secret, int secret_
 {
 	GNUTLS_MAC_HANDLE td1;
 
-	td1 = gnutls_hmac_init(algorithm, secret, secret_size);
-	gnutls_hmac(td1, seed, seed_size);
-	gnutls_hmac_deinit(td1, result);
+	td1 = _gnutls_hmac_init(algorithm, secret, secret_size);
+	_gnutls_hmac(td1, seed, seed_size);
+	_gnutls_hmac_deinit(td1, result);
 	
 	return;
 }
@@ -444,7 +444,7 @@ static void _gnutls_cal_PRF_A( MACAlgorithm algorithm, void *secret, int secret_
 /* Produces "total_bytes" bytes using the hash algorithm specified.
  * (used in the PRF function)
  */
-static int gnutls_P_hash( MACAlgorithm algorithm, opaque * secret, int secret_size, opaque * seed, int seed_size, int total_bytes, opaque* ret)
+static int _gnutls_P_hash( MACAlgorithm algorithm, opaque * secret, int secret_size, opaque * seed, int seed_size, int total_bytes, opaque* ret)
 {
 
 	GNUTLS_MAC_HANDLE td2;
@@ -456,7 +456,7 @@ static int gnutls_P_hash( MACAlgorithm algorithm, opaque * secret, int secret_si
 		return GNUTLS_E_INTERNAL_ERROR;
 	}
 	
-	blocksize = gnutls_hmac_get_algo_len(algorithm);
+	blocksize = _gnutls_hmac_get_algo_len(algorithm);
 	do {
 		i += blocksize;
 	} while (i < total_bytes);
@@ -468,16 +468,16 @@ static int gnutls_P_hash( MACAlgorithm algorithm, opaque * secret, int secret_si
 
 	times = i / blocksize;
 	for (i = 0; i < times; i++) {
-		td2 = gnutls_hmac_init(algorithm, secret, secret_size);
+		td2 = _gnutls_hmac_init(algorithm, secret, secret_size);
 
 		/* here we calculate A(i+1) */
 		_gnutls_cal_PRF_A( algorithm, secret, secret_size, Atmp, A_size, Atmp);
 
 		A_size = blocksize;
 
-		gnutls_hmac(td2, Atmp, A_size);
-		gnutls_hmac(td2, seed, seed_size);
-		gnutls_hmac_deinit(td2, final);
+		_gnutls_hmac(td2, Atmp, A_size);
+		_gnutls_hmac(td2, seed, seed_size);
+		_gnutls_hmac_deinit(td2, final);
 
 		if ( (1+i) * blocksize < total_bytes) {
 			how = blocksize;
@@ -553,13 +553,13 @@ int _gnutls_PRF( opaque * secret, int secret_size, uint8 * label, int label_size
 		l_s++;
 	}
 
-	result = gnutls_P_hash( GNUTLS_MAC_MD5, s1, l_s, s_seed, s_seed_size, total_bytes, o1);
+	result = _gnutls_P_hash( GNUTLS_MAC_MD5, s1, l_s, s_seed, s_seed_size, total_bytes, o1);
 	if (result<0) {
 		gnutls_assert();
 		return result;
 	}
 
-	result = gnutls_P_hash( GNUTLS_MAC_SHA, s2, l_s, s_seed, s_seed_size, total_bytes, o2);
+	result = _gnutls_P_hash( GNUTLS_MAC_SHA, s2, l_s, s_seed, s_seed_size, total_bytes, o2);
 	if (result<0) {
 		gnutls_assert();
 		return result;
diff --git a/lib/gnutls_ui.c b/lib/gnutls_ui.c
index 50528e1fb0..5f065350e4 100644
--- a/lib/gnutls_ui.c
+++ b/lib/gnutls_ui.c
@@ -276,7 +276,7 @@ typedef MACAlgorithm GNUTLS_DigestAlgorithm;
 int gnutls_x509_fingerprint(GNUTLS_DigestAlgorithm algo, const gnutls_datum* data, char* result, size_t* result_size)
 {
 	GNUTLS_HASH_HANDLE td;
-	int hash_len = gnutls_hash_get_algo_len(algo);
+	int hash_len = _gnutls_hash_get_algo_len(algo);
 	
 	if (hash_len > *result_size || hash_len < 0) {
 		*result_size = hash_len;
@@ -284,12 +284,12 @@ int gnutls_x509_fingerprint(GNUTLS_DigestAlgorithm algo, const gnutls_datum* dat
 	}
 	*result_size = hash_len;
 	
-	td = gnutls_hash_init( algo);
+	td = _gnutls_hash_init( algo);
 	if (td==NULL) return GNUTLS_E_HASH_FAILED;
 	
-	gnutls_hash( td, data->data, data->size);
+	_gnutls_hash( td, data->data, data->size);
 	
-	gnutls_hash_deinit( td, result);
+	_gnutls_hash_deinit( td, result);
 		
 	return 0;
 }
diff --git a/lib/x509_sig_check.c b/lib/x509_sig_check.c
index fb7e7cf5d4..3b8561e8e1 100644
--- a/lib/x509_sig_check.c
+++ b/lib/x509_sig_check.c
@@ -166,14 +166,14 @@ _pkcs1_rsa_verify_sig( const gnutls_datum* signature, gnutls_datum* text, MPI *p
 
 	gnutls_sfree_datum( &decrypted);
 
-	if (digest_size != gnutls_hash_get_algo_len(hash)) {
+	if (digest_size != _gnutls_hash_get_algo_len(hash)) {
 		gnutls_assert();
 		return GNUTLS_E_ASN1_GENERIC_ERROR;
 	}
 
-	hd = gnutls_hash_init( hash);
-	gnutls_hash( hd, text->data, text->size);
-	gnutls_hash_deinit( hd, md);
+	hd = _gnutls_hash_init( hash);
+	_gnutls_hash( hd, text->data, text->size);
+	_gnutls_hash_deinit( hd, md);
 
 	if (memcmp( md, digest, digest_size)!=0) {
 		gnutls_assert();