Prefixed internal functions with _gnutls_

17 files changed, 134 insertions, 138 deletions

diff --git a/lib/auth_anon.c b/lib/auth_anon.c
index b5e042eff0..7aa72f2619 100644
--- a/lib/auth_anon.c
+++ b/lib/auth_anon.c
@@ -121,19 +121,19 @@ int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
 	_gnutls_mpi_print( &data_p[2], &n_p, p);
 	_gnutls_mpi_release(&p);
 
-	WRITEuint16( n_p, data_p);
+	_gnutls_write_uint16( n_p, data_p);
 
 	data_g = &data_p[2 + n_p];
 	_gnutls_mpi_print( &data_g[2], &n_g, g);
 	_gnutls_mpi_release(&g);
 	
-	WRITEuint16( n_g, data_g);
+	_gnutls_write_uint16( n_g, data_g);
 
 	data_X = &data_g[2 + n_g];
 	_gnutls_mpi_print( &data_X[2], &n_X, X);
 	_gnutls_mpi_release(&X);
 
-	WRITEuint16( n_X, data_X);
+	_gnutls_write_uint16( n_X, data_X);
 
 	return n_p+n_g+n_X+6;
 }
@@ -167,7 +167,7 @@ int ret;
 				   certificate */
 	_gnutls_mpi_release(&X);
 	
-	WRITEuint16( n_X, &(*data)[0]);
+	_gnutls_write_uint16( n_X, &(*data)[0]);
 
 	/* calculate the key after calculating the message */
 	state->gnutls_key->KEY = gnutls_calc_dh_key(state->gnutls_key->client_Y, x, state->gnutls_key->client_p);
@@ -198,7 +198,7 @@ int proc_anon_server_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 
 	i = 0;
 	DECR_LEN( data_size, 2);
-	n_p = READuint16( &data[i]);
+	n_p = _gnutls_read_uint16( &data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_p);
@@ -209,7 +209,7 @@ int proc_anon_server_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 		return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
 	}
 	DECR_LEN( data_size, 2);
-	n_g = READuint16( &data[i]);
+	n_g = _gnutls_read_uint16( &data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_g);
@@ -217,7 +217,7 @@ int proc_anon_server_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 	i += n_g;
 	
 	DECR_LEN( data_size, 2);
-	n_Y = READuint16( &data[i]);
+	n_Y = _gnutls_read_uint16( &data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_Y);
@@ -290,7 +290,7 @@ int proc_anon_client_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 	bits = _gnutls_dh_get_prime_bits( state);
 
 	DECR_LEN( data_size, 2);
-	n_Y = READuint16( &data[0]);
+	n_Y = _gnutls_read_uint16( &data[0]);
 
 	_n_Y = n_Y;
 	DECR_LEN( data_size, n_Y);
diff --git a/lib/auth_cert.c b/lib/auth_cert.c
index 363bf5139a..b8934106fe 100644
--- a/lib/auth_cert.c
+++ b/lib/auth_cert.c
@@ -176,7 +176,7 @@ static int _find_x509_cert(const GNUTLS_CERTIFICATE_CREDENTIALS cred,
 	do {
 
 		DECR_LENGTH_RET(data_size, 2, 0);
-		size = READuint16(data);
+		size = _gnutls_read_uint16(data);
 		DECR_LENGTH_RET(data_size, size, 0);
 		data += 2;
 
@@ -343,7 +343,7 @@ static int _gnutls_find_acceptable_client_cert(GNUTLS_STATE state,
 			dataptr_size -= 2;
 			if (dataptr_size <= 0)
 				goto clear;
-			size = READuint16(data);
+			size = _gnutls_read_uint16(data);
 
 			dataptr_size -= size;
 			if (dataptr_size < 0)
@@ -384,7 +384,7 @@ static int _gnutls_find_acceptable_client_cert(GNUTLS_STATE state,
 				 */
 				data_size -= 2;
 
-				size = READuint16(data);
+				size = _gnutls_read_uint16(data);
 
 				data += 2;
 
@@ -497,10 +497,10 @@ int _gnutls_gen_x509_certificate(GNUTLS_STATE state, opaque ** data)
 		gnutls_assert();
 		return GNUTLS_E_MEMORY_ERROR;
 	}
-	WRITEuint24(ret - 3, pdata);
+	_gnutls_write_uint24(ret - 3, pdata);
 	pdata += 3;
 	for (i = 0; i < apr_cert_list_length; i++) {
-		WRITEdatum24(pdata, apr_cert_list[i].raw);
+		_gnutls_write_datum24(pdata, apr_cert_list[i].raw);
 		pdata += (3 + apr_cert_list[i].raw.size);
 	}
 
@@ -540,17 +540,17 @@ int _gnutls_gen_openpgp_certificate(GNUTLS_STATE state,
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	WRITEuint24(ret - 3, pdata);
+	_gnutls_write_uint24(ret - 3, pdata);
 	pdata += 3;
 
 	*pdata = PGP_KEY;	/* whole key */
 	pdata++;
 
 	if (apr_cert_list_length > 0) {
-		WRITEdatum24(pdata, apr_cert_list[0].raw);
+		_gnutls_write_datum24(pdata, apr_cert_list[0].raw);
 		pdata += (3 + apr_cert_list[0].raw.size);
 	} else			/* empty - no certificate */
-		WRITEuint24(0, pdata);
+		_gnutls_write_uint24(0, pdata);
 
 	return ret;
 }
@@ -594,7 +594,7 @@ int _gnutls_gen_openpgp_certificate_fpr(GNUTLS_STATE state,
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	WRITEuint24(packet_size - 3, pdata);
+	_gnutls_write_uint24(packet_size - 3, pdata);
 	pdata += 3;
 
 	*pdata = PGP_KEY_FINGERPRINT;	/* key fingerprint */
@@ -698,7 +698,7 @@ int _gnutls_proc_x509_server_certificate(GNUTLS_STATE state, opaque * data,
 	}
 
 	DECR_LEN(dsize, 3);
-	size = READuint24(p);
+	size = _gnutls_read_uint24(p);
 	p += 3;
 
 	if (size == 0) {
@@ -710,7 +710,7 @@ int _gnutls_proc_x509_server_certificate(GNUTLS_STATE state, opaque * data,
 	i = dsize;
 	while(i > 0) {
 		DECR_LEN(dsize, 3);
-		len = READuint24(p);
+		len = _gnutls_read_uint24(p);
 		p += 3;
 		DECR_LEN(dsize, len);
 		peer_certificate_list_size++;
@@ -746,7 +746,7 @@ int _gnutls_proc_x509_server_certificate(GNUTLS_STATE state, opaque * data,
 	 */
 
 	for (j=0;j<peer_certificate_list_size;j++) {
-		len = READuint24(p);
+		len = _gnutls_read_uint24(p);
 		p += 3;
 
 		tmp.size = len;
@@ -830,7 +830,7 @@ int _gnutls_proc_openpgp_server_certificate(GNUTLS_STATE state,
 	}
 
 	DECR_LEN(dsize, 3);
-	size = READuint24(p);
+	size = _gnutls_read_uint24(p);
 	p += 3;
 
 	if (size == 0) {
@@ -875,7 +875,7 @@ int _gnutls_proc_openpgp_server_certificate(GNUTLS_STATE state,
 
 		/* Read the actual certificate */
 		DECR_LEN(dsize, 3);
-		len = READuint24(p);
+		len = _gnutls_read_uint24(p);
 		p += 3;
 
 		if (size == 0) {
@@ -1050,7 +1050,7 @@ int _gnutls_proc_cert_cert_req(GNUTLS_STATE state, opaque * data,
 
 	if (state->security_parameters.cert_type == GNUTLS_CRT_X509) {
 		DECR_LEN(dsize, 2);
-		size = READuint16(p);
+		size = _gnutls_read_uint16(p);
 		p += 2;
 	} else {
 		p = NULL;
@@ -1118,7 +1118,7 @@ int _gnutls_gen_cert_client_cert_vrfy(GNUTLS_STATE state, opaque ** data)
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 	size = signature.size;
-	WRITEuint16(size, *data);
+	_gnutls_write_uint16(size, *data);
 
 	memcpy(&(*data)[2], signature.data, size);
 
@@ -1144,7 +1144,7 @@ int _gnutls_proc_cert_client_cert_vrfy(GNUTLS_STATE state, opaque * data,
 	}
 
 	DECR_LEN(dsize, 2);
-	size = READuint16(pdata);
+	size = _gnutls_read_uint16(pdata);
 	pdata += 2;
 
 	DECR_LEN(dsize, size);
@@ -1234,7 +1234,7 @@ int _gnutls_gen_cert_server_cert_req(GNUTLS_STATE state, opaque ** data)
 	pdata += CERTTYPE_SIZE;
 
 	if (state->security_parameters.cert_type == GNUTLS_CRT_X509) {
-		WRITEdatum16(pdata, cred->x509_rdn_sequence);
+		_gnutls_write_datum16(pdata, cred->x509_rdn_sequence);
 		pdata += cred->x509_rdn_sequence.size + 2;
 	}
 
diff --git a/lib/auth_dhe.c b/lib/auth_dhe.c
index bd0b501521..4367e8df14 100644
--- a/lib/auth_dhe.c
+++ b/lib/auth_dhe.c
@@ -159,19 +159,19 @@ static int gen_dhe_server_kx(GNUTLS_STATE state, opaque ** data)
 	_gnutls_mpi_print( &data_p[2], &n_p, p);
 	_gnutls_mpi_release(&p);
 
-	WRITEuint16(n_p, data_p);
+	_gnutls_write_uint16(n_p, data_p);
 
 	data_g = &data_p[2 + n_p];
 	_gnutls_mpi_print( &data_g[2], &n_g, g);
 	_gnutls_mpi_release(&g);
 
-	WRITEuint16(n_g, data_g);
+	_gnutls_write_uint16(n_g, data_g);
 
 	data_X = &data_g[2 + n_g];
 	_gnutls_mpi_print( &data_X[2], &n_X, X);
 	_gnutls_mpi_release(&X);
 
-	WRITEuint16(n_X, data_X);
+	_gnutls_write_uint16(n_X, data_X);
 
 	data_size = n_p + n_g + n_X + 6;
 
@@ -202,7 +202,7 @@ static int gen_dhe_server_kx(GNUTLS_STATE state, opaque ** data)
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	WRITEdatum16(&(*data)[data_size], signature);
+	_gnutls_write_datum16(&(*data)[data_size], signature);
 	data_size += signature.size + 2;
 
 	gnutls_free_datum(&signature);
@@ -242,7 +242,7 @@ static int gen_dhe_client_kx(GNUTLS_STATE state, opaque ** data)
 	_gnutls_mpi_print( &(*data)[2], &n_X, X);
 	_gnutls_mpi_release(&X);
 
-	WRITEuint16(n_X, &(*data)[0]);
+	_gnutls_write_uint16(n_X, &(*data)[0]);
 
 	/* calculate the key after calculating the message */
 	state->gnutls_key->KEY =
@@ -303,7 +303,7 @@ static int proc_dhe_server_kx(GNUTLS_STATE state, opaque * data,
 	i = 0;
 	
 	DECR_LEN( data_size, 2);
-	n_p = READuint16(&data[i]);
+	n_p = _gnutls_read_uint16(&data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_p);
@@ -315,7 +315,7 @@ static int proc_dhe_server_kx(GNUTLS_STATE state, opaque * data,
 	}
 
 	DECR_LEN( data_size, 2);
-	n_g = READuint16(&data[i]);
+	n_g = _gnutls_read_uint16(&data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_g);
@@ -327,7 +327,7 @@ static int proc_dhe_server_kx(GNUTLS_STATE state, opaque * data,
 	}
 
 	DECR_LEN( data_size, 2);
-	n_Y = READuint16(&data[i]);
+	n_Y = _gnutls_read_uint16(&data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_Y);
@@ -379,7 +379,7 @@ static int proc_dhe_server_kx(GNUTLS_STATE state, opaque * data,
 	vparams.data = data;
 
 	DECR_LEN( data_size, 2);
-	sigsize = READuint16(&data[vparams.size]);
+	sigsize = _gnutls_read_uint16(&data[vparams.size]);
 
 	DECR_LEN( data_size, sigsize);
 	signature.data = &data[vparams.size + 2];
@@ -445,7 +445,7 @@ static int proc_dhe_client_kx(GNUTLS_STATE state, opaque * data,
 	bits = _gnutls_dh_get_prime_bits( state);
 
 	DECR_LEN( data_size, 2);
-	n_Y = READuint16(&data[0]);
+	n_Y = _gnutls_read_uint16(&data[0]);
 	_n_Y = n_Y;
 
 	DECR_LEN( data_size, n_Y);
diff --git a/lib/auth_rsa.c b/lib/auth_rsa.c
index 01c159e99d..828fae85d2 100644
--- a/lib/auth_rsa.c
+++ b/lib/auth_rsa.c
@@ -167,7 +167,7 @@ int proc_rsa_client_kx(GNUTLS_STATE state, opaque * data, int data_size)
 		ciphertext.size = data_size;
 	} else {		/* TLS 1 */
 		ciphertext.data = &data[2];
-		dsize = READuint16(data);
+		dsize = _gnutls_read_uint16(data);
 
 		if (dsize != data_size - 2) {
 			gnutls_assert();
@@ -270,7 +270,7 @@ int gen_rsa_client_kx(GNUTLS_STATE state, opaque ** data)
 			gnutls_free_datum(&sdata);
 			return GNUTLS_E_MEMORY_ERROR;
 		}
-		WRITEdatum16( *data, sdata);
+		_gnutls_write_datum16( *data, sdata);
 		ret = sdata.size + 2;
 		gnutls_free_datum(&sdata);
 		return ret;
diff --git a/lib/gnutls_cipher.c b/lib/gnutls_cipher.c
index 599bee7318..e234eb1483 100644
--- a/lib/gnutls_cipher.c
+++ b/lib/gnutls_cipher.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2000,2001 Nikos Mavroyanopoulos
+ * Copyright (C) 2000,2001,2002 Nikos Mavroyanopoulos
  *
  * This file is part of GNUTLS.
  *
@@ -90,7 +90,7 @@ int _gnutls_encrypt(GNUTLS_STATE state, const char* headers, int headers_size,
 
 	/* copy the headers */
 	memcpy( ciphertext, headers, headers_size);
-	WRITEuint16( ret, &ciphertext[3]);
+	_gnutls_write_uint16( ret, &ciphertext[3]);
 
 	return ret+headers_size;
 }
@@ -263,9 +263,9 @@ int _gnutls_compressed2ciphertext(GNUTLS_STATE state,
 		return GNUTLS_E_UNKNOWN_MAC_ALGORITHM;
 	}
 
-	c_length = CONVuint16(compressed.size);
+	c_length = _gnutls_conv_uint16(compressed.size);
 	seq_num =
-	    CONVuint64(&state->connection_state.write_sequence_number);
+	    _gnutls_conv_uint64(&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);
@@ -419,8 +419,8 @@ int _gnutls_ciphertext2compressed(GNUTLS_STATE state,
 	memcpy( compress_data, ciphertext.data, length);
 
 
-	c_length = CONVuint16((uint16) length);
-	seq_num = CONVuint64( &state->connection_state.read_sequence_number);
+	c_length = _gnutls_conv_uint16((uint16) length);
+	seq_num = _gnutls_conv_uint64( &state->connection_state.read_sequence_number);
 
 	/* Pass the type, version, length and compressed through
 	 * MAC.
diff --git a/lib/gnutls_constate.c b/lib/gnutls_constate.c
index 65bef08c80..a681427559 100644
--- a/lib/gnutls_constate.c
+++ b/lib/gnutls_constate.c
@@ -221,7 +221,7 @@ int _gnutls_read_connection_state_init(GNUTLS_STATE state) {
 int mac_size;
 int rc;
 
-	uint64zero(&state->connection_state.read_sequence_number);
+	_gnutls_uint64zero(&state->connection_state.read_sequence_number);
 
 /* Update internals from CipherSuite selected.
  * If we are resuming just copy the connection state
@@ -378,7 +378,7 @@ int _gnutls_write_connection_state_init(GNUTLS_STATE state) {
 int mac_size;
 int rc;
 
-	uint64zero(&state->connection_state.write_sequence_number);
+	_gnutls_uint64zero(&state->connection_state.write_sequence_number);
 
 /* Update internals from CipherSuite selected.
  * If we are resuming just copy the connection state
diff --git a/lib/gnutls_datum.c b/lib/gnutls_datum.c
index 30c8e23c3d..7f5eb9032f 100644
--- a/lib/gnutls_datum.c
+++ b/lib/gnutls_datum.c
@@ -1,5 +1,5 @@
 /*
- *      Copyright (C) 2001 Nikos Mavroyanopoulos
+ *      Copyright (C) 2001,2002 Nikos Mavroyanopoulos
  *
  * This file is part of GNUTLS.
  *
@@ -29,19 +29,19 @@
  * should be preallocated (datum.size+(bits/8))
  */
 
-void WRITEdatum16( opaque* dest, gnutls_datum dat) {
-	WRITEuint16( dat.size, dest);
+void _gnutls_write_datum16( opaque* dest, gnutls_datum dat) {
+	_gnutls_write_uint16( dat.size, dest);
 	memcpy( &dest[2], dat.data, dat.size);
 }
-void WRITEdatum24( opaque* dest, gnutls_datum dat) {
-	WRITEuint24( dat.size, dest);
+void _gnutls_write_datum24( opaque* dest, gnutls_datum dat) {
+	_gnutls_write_uint24( dat.size, dest);
 	memcpy( &dest[3], dat.data, dat.size);
 }
-void WRITEdatum32( opaque* dest, gnutls_datum dat) {
-	WRITEuint32( dat.size, dest);
+void _gnutls_write_datum32( opaque* dest, gnutls_datum dat) {
+	_gnutls_write_uint32( dat.size, dest);
 	memcpy( &dest[4], dat.data, dat.size);
 }
-void WRITEdatum8( opaque* dest, gnutls_datum dat) {
+void _gnutls_write_datum8( opaque* dest, gnutls_datum dat) {
 	dest[0] = (uint8) dat.size;
 	memcpy( &dest[1], dat.data, dat.size);
 }
diff --git a/lib/gnutls_datum.h b/lib/gnutls_datum.h
index bbbc9dd2ee..74c0ca8a81 100644
--- a/lib/gnutls_datum.h
+++ b/lib/gnutls_datum.h
@@ -1,7 +1,7 @@
-void WRITEdatum16( opaque* dest, gnutls_datum dat);
-void WRITEdatum24( opaque* dest, gnutls_datum dat);
-void WRITEdatum32( opaque* dest, gnutls_datum dat);
-void WRITEdatum8( opaque* dest, gnutls_datum dat);
+void _gnutls_write_datum16( opaque* dest, gnutls_datum dat);
+void _gnutls_write_datum24( opaque* dest, gnutls_datum dat);
+void _gnutls_write_datum32( opaque* dest, gnutls_datum dat);
+void _gnutls_write_datum8( opaque* dest, gnutls_datum dat);
 
 int gnutls_set_datum( gnutls_datum* dat, const void* data, int data_size);
 int gnutls_datum_append( gnutls_datum* dat, const void* data, int data_size);
diff --git a/lib/gnutls_extensions.c b/lib/gnutls_extensions.c
index 8610dc738d..2a85bd2837 100644
--- a/lib/gnutls_extensions.c
+++ b/lib/gnutls_extensions.c
@@ -109,14 +109,14 @@ int i;
 #endif
 
 	DECR_LENGTH_RET( data_size, 2, 0);
-	next = READuint16( data);
+	next = _gnutls_read_uint16( data);
 	pos+=2;
 
 	DECR_LENGTH_RET( data_size, next, 0);
 	
 	do {
 		DECR_LENGTH_RET( next, 1, 0);
-		type = READuint16( &data[pos]);
+		type = _gnutls_read_uint16( &data[pos]);
 		pos+=2;
 		
 		if ( (ret=_gnutls_extension_list_check( state, type)) < 0) {
@@ -125,7 +125,7 @@ int i;
 		}
 
 		DECR_LENGTH_RET( next, 2, 0);
-		size = READuint16(&data[pos]);
+		size = _gnutls_read_uint16(&data[pos]);
 		pos+=2;
 				
 		DECR_LENGTH_RET( next, size, 0);
@@ -198,11 +198,11 @@ int (*ext_func_send)( GNUTLS_STATE, opaque*, int);
 			}
 
 			/* write extension type */
-			WRITEuint16( next, &(*data)[pos]);
+			_gnutls_write_uint16( next, &(*data)[pos]);
 			pos+=2;
 			
 			/* write size */
-			WRITEuint16( size, &(*data)[pos]);
+			_gnutls_write_uint16( size, &(*data)[pos]);
 			pos+=2;
 			
 			memcpy( &(*data)[pos], sdata, size);
@@ -218,7 +218,7 @@ int (*ext_func_send)( GNUTLS_STATE, opaque*, int);
 	size = pos;
 	pos-=2; /* remove the size of the size header! */
 
-	WRITEuint16( pos, (*data));
+	_gnutls_write_uint16( pos, (*data));
 
 	if (size==2) { /* empty */
 		size = 0;
diff --git a/lib/gnutls_handshake.c b/lib/gnutls_handshake.c
index c744906127..cf2ea02a29 100644
--- a/lib/gnutls_handshake.c
+++ b/lib/gnutls_handshake.c
@@ -214,7 +214,7 @@ int _gnutls_create_random(opaque * dst)
 
 	tim = time(NULL);
 	/* generate server random value */
-	WRITEuint32(tim, dst);
+	_gnutls_write_uint32(tim, dst);
 
 	if (_gnutls_get_random
 	    (rand, TLS_RANDOM_SIZE - 4, GNUTLS_STRONG_RANDOM) < 0) {
@@ -315,7 +315,7 @@ int _gnutls_read_client_hello(GNUTLS_STATE state, opaque * data,
 	/* Select a ciphersuite 
 	 */
 	DECR_LEN(len, 2);
-	sizeOfSuites = READuint16(&data[pos]);
+	sizeOfSuites = _gnutls_read_uint16(&data[pos]);
 	pos += 2;
 
 	DECR_LEN(len, sizeOfSuites);
@@ -735,7 +735,7 @@ int _gnutls_send_handshake(GNUTLS_STATE state, void *i_data,
 	}
 
 	data[pos++] = (uint8) type;
-	WRITEuint24(i_datasize, &data[pos]);
+	_gnutls_write_uint24(i_datasize, &data[pos]);
 	pos += 3;
 
 	if (i_datasize > 0)
@@ -857,7 +857,7 @@ static int _gnutls_recv_handshake_header(GNUTLS_STATE state,
 		/* we do not use DECR_LEN because we know
 		 * that the packet has enough data.
 		 */
-		length32 = READuint24(&dataptr[1]);
+		length32 = _gnutls_read_uint24(&dataptr[1]);
 		handshake_header_size = HANDSHAKE_HEADER_SIZE;
 
 		_gnutls_handshake_log("HSK: %s was received [%ld bytes]\n",
@@ -1351,7 +1351,7 @@ static int _gnutls_copy_ciphersuites(GNUTLS_STATE state,
 	}
 
 
-	WRITEuint16(x, *ret_data);
+	_gnutls_write_uint16(x, *ret_data);
 	pos += 2;
 
 	for (i = 0; i < x / 2; i++) {
diff --git a/lib/gnutls_num.c b/lib/gnutls_num.c
index 1abd35aabf..8f165353d3 100644
--- a/lib/gnutls_num.c
+++ b/lib/gnutls_num.c
@@ -1,5 +1,5 @@
 /*
- *      Copyright (C) 2000,2001 Nikos Mavroyanopoulos
+ *      Copyright (C) 2000,2001,2002 Nikos Mavroyanopoulos
  *
  * This file is part of GNUTLS.
  *
@@ -28,7 +28,7 @@
 
 /* This function will set the uint64 x to zero 
  */
-int uint64zero( uint64 *x) {
+int _gnutls_uint64zero( uint64 *x) {
 
 	memset( x->i, 0, 8);
 	return 0;
@@ -38,7 +38,7 @@ int uint64zero( uint64 *x) {
  * Returns 0 on success, or -1 if the uint64 max limit
  * has been reached.
  */
-int uint64pp( uint64 *x) {
+int _gnutls_uint64pp( uint64 *x) {
 register int i, y=0;
 
 	for (i=7;i>=0;i--) {
@@ -57,7 +57,7 @@ register int i, y=0;
 
 #endif /* HAVE_UINT64 */
 
-uint32 uint24touint32( uint24 num) {
+uint32 _gnutls_uint24touint32( uint24 num) {
 uint32 ret=0;
 
 	((uint8*)&ret)[1] = num.pint[0];
@@ -66,7 +66,7 @@ uint32 ret=0;
 	return ret;
 }
 
-uint24 uint32touint24( uint32 num) {
+uint24 _gnutls_uint32touint24( uint32 num) {
 uint24 ret;
 
 	ret.pint[0] = ((uint8*)&num)[1];
@@ -77,7 +77,7 @@ uint24 ret;
 }
 
 /* data should be at least 3 bytes */
-uint32 READuint24( const opaque* data) {
+uint32 _gnutls_read_uint24( const opaque* data) {
 uint32 res;
 uint24 num;
 	
@@ -85,20 +85,20 @@ uint24 num;
 	num.pint[1] = data[1];
 	num.pint[2] = data[2];
 
-	res = uint24touint32( num);
+	res = _gnutls_uint24touint32( num);
 #ifndef WORDS_BIGENDIAN
 	res = byteswap32( res);
 #endif
 return res;
 }
 
-void WRITEuint24( uint32 num, opaque* data) {
+void _gnutls_write_uint24( uint32 num, opaque* data) {
 uint24 tmp;
 	
 #ifndef WORDS_BIGENDIAN
 	num = byteswap32( num);
 #endif
-	tmp = uint32touint24( num);
+	tmp = _gnutls_uint32touint24( num);
 
 	data[0] = tmp.pint[0];
 	data[1] = tmp.pint[1];
@@ -106,7 +106,7 @@ uint24 tmp;
 	return;
 }
 
-uint32 READuint32( const opaque* data) {
+uint32 _gnutls_read_uint32( const opaque* data) {
 uint32 res;
 
 	memcpy( &res, data, sizeof(uint32));
@@ -116,7 +116,7 @@ uint32 res;
 return res;
 }
 
-void WRITEuint32( uint32 num, opaque* data) {
+void _gnutls_write_uint32( uint32 num, opaque* data) {
 
 #ifndef WORDS_BIGENDIAN
 	num = byteswap32( num);
@@ -125,7 +125,7 @@ void WRITEuint32( uint32 num, opaque* data) {
 	return;
 }
 
-uint16 READuint16( const opaque* data) {
+uint16 _gnutls_read_uint16( const opaque* data) {
 uint16 res;
 	memcpy( &res, data, sizeof(uint16));
 #ifndef WORDS_BIGENDIAN
@@ -134,7 +134,7 @@ uint16 res;
 return res;
 }
 
-void WRITEuint16( uint16 num, opaque* data) {
+void _gnutls_write_uint16( uint16 num, opaque* data) {
 
 #ifndef WORDS_BIGENDIAN
 	num = byteswap16( num);
@@ -143,7 +143,7 @@ void WRITEuint16( uint16 num, opaque* data) {
 	return;
 }
 
-uint32 CONVuint32( uint32 data) {
+uint32 _gnutls_conv_uint32( uint32 data) {
 #ifndef WORDS_BIGENDIAN
 	return byteswap32( data);
 #else
@@ -151,7 +151,7 @@ uint32 CONVuint32( uint32 data) {
 #endif
 }
 
-uint16 CONVuint16( uint16 data) {
+uint16 _gnutls_conv_uint16( uint16 data) {
 #ifndef WORDS_BIGENDIAN
 	return byteswap16( data);
 #else
@@ -159,7 +159,7 @@ uint16 CONVuint16( uint16 data) {
 #endif
 }
 
-uint64 CONVuint64( const uint64* data) {
+uint64 _gnutls_conv_uint64( const uint64* data) {
 #ifdef HAVE_UINT64
 # ifndef WORDS_BIGENDIAN
 	return byteswap64(*data);
@@ -174,7 +174,7 @@ uint64 CONVuint64( const uint64* data) {
 #endif /* HAVE_UINT64 */
 }
 
-uint32 uint64touint32( const uint64* num) {
+uint32 _gnutls_uint64touint32( const uint64* num) {
 uint32 ret;
 
 #ifdef HAVE_UINT64
@@ -188,10 +188,6 @@ uint32 ret;
 # endif
 #endif /* HAVE_UINT64 */
 
- 
-
  return ret;
 }
 
-
-
diff --git a/lib/gnutls_num.h b/lib/gnutls_num.h
index b5d2d4e756..4e43d4e985 100644
--- a/lib/gnutls_num.h
+++ b/lib/gnutls_num.h
@@ -31,22 +31,22 @@
 #define byteswap16(x)  ((rotl16(x, 8) & 0x00ff) | (rotr16(x, 8) & 0xff00))
 #define byteswap32(x)  ((rotl32(x, 8) & 0x00ff00ffUL) | (rotr32(x, 8) & 0xff00ff00UL))
 
-uint32 uint24touint32( uint24 num);
-uint24 uint32touint24( uint32 num);
-uint32 READuint32( const opaque* data);
-uint16 READuint16( const opaque* data);
-uint32 CONVuint32( uint32 data);
-uint16 CONVuint16( uint16 data);
-uint64 CONVuint64( const uint64 *data);
-uint32 READuint24( const opaque* data);
-void WRITEuint24( uint32 num, opaque* data);
-void WRITEuint32( uint32 num, opaque* data);
-void WRITEuint16( uint16 num, opaque* data);
-uint32 uint64touint32( const uint64*);
+uint32 _gnutls_uint24touint32( uint24 num);
+uint24 _gnutls_uint32touint24( uint32 num);
+uint32 _gnutls_read_uint32( const opaque* data);
+uint16 _gnutls_read_uint16( const opaque* data);
+uint32 _gnutls_conv_uint32( uint32 data);
+uint16 _gnutls_conv_uint16( uint16 data);
+uint64 _gnutls_conv_uint64( const uint64 *data);
+uint32 _gnutls_read_uint24( const opaque* data);
+void _gnutls_write_uint24( uint32 num, opaque* data);
+void _gnutls_write_uint32( uint32 num, opaque* data);
+void _gnutls_write_uint16( uint16 num, opaque* data);
+uint32 _gnutls_uint64touint32( const uint64*);
 
 #ifndef HAVE_UINT64
-int uint64zero( uint64 *);
-int uint64pp( uint64 *);
+int _gnutls_uint64zero( uint64 *);
+int _gnutls_uint64pp( uint64 *);
 # define UINT64DATA(x) x.i
 
 #else
diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index ff0aac1ef2..8b9b8c662c 100644
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -217,7 +217,7 @@ ssize_t _gnutls_create_empty_record( GNUTLS_STATE state, ContentType type,
 
 	/* increase sequence number
 	 */
-	if (uint64pp( &state->connection_state.write_sequence_number) != 0) {
+	if (_gnutls_uint64pp( &state->connection_state.write_sequence_number) != 0) {
 		_gnutls_session_invalidate( state);
 		gnutls_assert();
 		return GNUTLS_E_RECORD_LIMIT_REACHED;
@@ -273,7 +273,7 @@ ssize_t gnutls_send_int( GNUTLS_STATE state, ContentType type, HandshakeType hty
 	headers[2]=_gnutls_version_get_minor( lver);
 
 	_gnutls_record_log( "REC: Sending Packet[%d] %s(%d) with length: %d\n",
-		(int) uint64touint32(&state->connection_state.write_sequence_number), _gnutls_packet2str(type), type, sizeofdata);
+		(int) _gnutls_uint64touint32(&state->connection_state.write_sequence_number), _gnutls_packet2str(type), type, sizeofdata);
 
 	if ( sizeofdata > MAX_RECORD_SIZE)
 		data2send_size = MAX_RECORD_SIZE;
@@ -338,7 +338,7 @@ ssize_t gnutls_send_int( GNUTLS_STATE state, ContentType type, HandshakeType hty
 
 		/* increase sequence number
 		 */
-		if (uint64pp( &state->connection_state.write_sequence_number) != 0) {
+		if (_gnutls_uint64pp( &state->connection_state.write_sequence_number) != 0) {
 			_gnutls_session_invalidate( state);
 			gnutls_assert();
 			gnutls_afree( erecord);
@@ -374,7 +374,7 @@ ssize_t gnutls_send_int( GNUTLS_STATE state, ContentType type, HandshakeType hty
 	state->gnutls_internals.record_send_buffer_user_size = 0;
 
 	_gnutls_record_log( "REC: Sent Packet[%d] %s(%d) with length: %d\n",
-	(int) uint64touint32(&state->connection_state.write_sequence_number), _gnutls_packet2str(type), type, cipher_size);
+	(int) _gnutls_uint64touint32(&state->connection_state.write_sequence_number), _gnutls_packet2str(type), type, cipher_size);
 
 	return retval;
 }
@@ -477,7 +477,7 @@ static int _gnutls_check_record_headers( GNUTLS_STATE state, uint8 headers[RECOR
 		*version = _gnutls_version_get( headers[1], headers[2]);
 #endif
 
-		*length = READuint16( &headers[3]);
+		*length = _gnutls_read_uint16( &headers[3]);
 	}
 
 	return 0;
@@ -683,9 +683,9 @@ ssize_t gnutls_recv_int( GNUTLS_STATE state, ContentType type, HandshakeType hty
 	}
 
 	_gnutls_record_log( "REC: Expected Packet[%d] %s(%d) with length: %d\n",
-		(int) uint64touint32(&state->connection_state.read_sequence_number), _gnutls_packet2str(type), type, sizeofdata);
+		(int) _gnutls_uint64touint32(&state->connection_state.read_sequence_number), _gnutls_packet2str(type), type, sizeofdata);
 	_gnutls_record_log( "REC: Received Packet[%d] %s(%d) with length: %d\n",
-		(int) uint64touint32(&state->connection_state.read_sequence_number), _gnutls_packet2str(recv_type), recv_type, length);
+		(int) _gnutls_uint64touint32(&state->connection_state.read_sequence_number), _gnutls_packet2str(recv_type), recv_type, length);
 
 	if (length > MAX_RECV_SIZE) {
 
@@ -750,10 +750,10 @@ ssize_t gnutls_recv_int( GNUTLS_STATE state, ContentType type, HandshakeType hty
 	}
 
 	_gnutls_record_log( "REC: Decrypted Packet[%d] %s(%d) with length: %d\n",
-		(int) uint64touint32(&state->connection_state.read_sequence_number), _gnutls_packet2str(recv_type), recv_type, tmplen);
+		(int) _gnutls_uint64touint32(&state->connection_state.read_sequence_number), _gnutls_packet2str(recv_type), recv_type, tmplen);
 
 	/* increase sequence number */
-	if (uint64pp( &state->connection_state.read_sequence_number)!=0) {
+	if (_gnutls_uint64pp( &state->connection_state.read_sequence_number)!=0) {
 		_gnutls_session_invalidate( state);
 		gnutls_afree(tmpdata);
 		gnutls_assert();
diff --git a/lib/gnutls_session_pack.c b/lib/gnutls_session_pack.c
index 8b8cd24193..a8e5a71228 100644
--- a/lib/gnutls_session_pack.c
+++ b/lib/gnutls_session_pack.c
@@ -68,7 +68,7 @@ int _gnutls_session_pack(GNUTLS_STATE state, gnutls_datum * packed_session)
 			    PACK_HEADER_SIZE + pack_size + sizeof(uint32);
 
 			packed_session->data[0] = GNUTLS_CRD_SRP;
-			WRITEuint32(pack_size,
+			_gnutls_write_uint32(pack_size,
 				    &packed_session->
 				    data[PACK_HEADER_SIZE]);
 			
@@ -93,7 +93,7 @@ int _gnutls_session_pack(GNUTLS_STATE state, gnutls_datum * packed_session)
 			    PACK_HEADER_SIZE + state->gnutls_key->auth_info_size + sizeof(uint32);
 
 			packed_session->data[0] = GNUTLS_CRD_ANON;
-			WRITEuint32(state->gnutls_key->auth_info_size,
+			_gnutls_write_uint32(state->gnutls_key->auth_info_size,
 				    &packed_session->
 				    data[PACK_HEADER_SIZE]);
 			
@@ -130,7 +130,7 @@ int _gnutls_session_pack(GNUTLS_STATE state, gnutls_datum * packed_session)
 	 */
 	packed_session->size += sizeof(SecurityParameters)+sizeof(uint32);
 
-	WRITEuint32( sizeof(SecurityParameters), &packed_session->data[packed_session->size - sizeof(SecurityParameters) - sizeof(uint32)]);
+	_gnutls_write_uint32( sizeof(SecurityParameters), &packed_session->data[packed_session->size - sizeof(SecurityParameters) - sizeof(uint32)]);
 	memcpy(&packed_session->
 	       data[packed_session->size - sizeof(SecurityParameters)],
 	       &state->security_parameters, sizeof(SecurityParameters));
@@ -190,7 +190,7 @@ int _gnutls_session_unpack(GNUTLS_STATE state,
 	case GNUTLS_CRD_SRP:{
 
 			pack_size =
-			    READuint32(&packed_session->
+			    _gnutls_read_uint32(&packed_session->
 				       data[PACK_HEADER_SIZE]);
 			
 			if (pack_size == 0) break;
@@ -219,7 +219,7 @@ int _gnutls_session_unpack(GNUTLS_STATE state,
 #endif
 	case GNUTLS_CRD_ANON:{
 			pack_size =
-			    READuint32(&packed_session->
+			    _gnutls_read_uint32(&packed_session->
 				       data[PACK_HEADER_SIZE]);
 
 			if (pack_size == 0) break;
@@ -245,7 +245,7 @@ int _gnutls_session_unpack(GNUTLS_STATE state,
 		break;
 	case GNUTLS_CRD_CERTIFICATE:{
 			pack_size =
-			    READuint32(&packed_session->
+			    _gnutls_read_uint32(&packed_session->
 				       data[PACK_HEADER_SIZE]);
 			
 			if (pack_size == 0) {
@@ -291,7 +291,7 @@ int _gnutls_session_unpack(GNUTLS_STATE state,
 	/* Auth_info structures copied. Now copy SecurityParameters. 
 	 */
 	ret =
-	    READuint32(&packed_session->
+	    _gnutls_read_uint32(&packed_session->
 		       data[PACK_HEADER_SIZE + sizeof(uint32) +
 			    pack_size]);
 
@@ -329,7 +329,7 @@ int _gnutls_pack_certificate_auth_info( CERTIFICATE_AUTH_INFO info,
 	else info_size = sizeof(CERTIFICATE_AUTH_INFO_INT);
 
 	packed_session->data[0] = GNUTLS_CRD_CERTIFICATE;
-	WRITEuint32( packed_session->size-PACK_HEADER_SIZE-sizeof(uint32), &packed_session->data[PACK_HEADER_SIZE]);
+	_gnutls_write_uint32( packed_session->size-PACK_HEADER_SIZE-sizeof(uint32), &packed_session->data[PACK_HEADER_SIZE]);
 
 	if (info!=NULL) {
 		memcpy(&packed_session->data[PACK_HEADER_SIZE + sizeof(uint32)],
@@ -340,7 +340,7 @@ int _gnutls_pack_certificate_auth_info( CERTIFICATE_AUTH_INFO info,
 
 	if (info!=NULL) {
 		for (i=0;i<info->ncerts;i++) {
-			WRITEuint32( info->raw_certificate_list[i].size, &packed_session->data[pos]);
+			_gnutls_write_uint32( info->raw_certificate_list[i].size, &packed_session->data[pos]);
 			pos += sizeof(uint32);
 		
 			memcpy(&packed_session->data[pos], info->raw_certificate_list[i].data, info->raw_certificate_list[i].size);
@@ -386,7 +386,7 @@ uint32 size;
 		}
 		
 		for (i=0;i<info->ncerts;i++) {
-			size = READuint32( &packed_session->data[ pos]);
+			size = _gnutls_read_uint32( &packed_session->data[ pos]);
 			pos += sizeof(uint32);
 
 			ret = gnutls_set_datum( &info->raw_certificate_list[i], &packed_session->data[ pos], size);
diff --git a/lib/gnutls_v2_compat.c b/lib/gnutls_v2_compat.c
index 866a1c788f..3f6ab174af 100644
--- a/lib/gnutls_v2_compat.c
+++ b/lib/gnutls_v2_compat.c
@@ -117,12 +117,12 @@ int _gnutls_read_client_hello_v2(GNUTLS_STATE state, opaque * data,
 
 	/* Read uint16 cipher_spec_length */
 	DECR_LEN(len, 2);
-	sizeOfSuites = READuint16( &data[pos]);
+	sizeOfSuites = _gnutls_read_uint16( &data[pos]);
 	pos += 2;
 	
 	/* read session id length */
 	DECR_LEN(len, 2);
-	session_id_len = READuint16( &data[pos]);
+	session_id_len = _gnutls_read_uint16( &data[pos]);
 	pos += 2;
 
 	if (session_id_len > TLS_MAX_SESSION_ID_SIZE) { 
@@ -132,7 +132,7 @@ int _gnutls_read_client_hello_v2(GNUTLS_STATE state, opaque * data,
 
 	/* read challenge length */
 	DECR_LEN(len, 2);
-	challenge = READuint16( &data[pos]);
+	challenge = _gnutls_read_uint16( &data[pos]);
 	pos += 2;
 
 	if ( challenge < 16 || challenge > TLS_RANDOM_SIZE) {
diff --git a/lib/gnutls_x509.c b/lib/gnutls_x509.c
index f5680dd372..bc7c6d3226 100644
--- a/lib/gnutls_x509.c
+++ b/lib/gnutls_x509.c
@@ -1516,7 +1516,7 @@ opaque *pdata;
 			gnutls_assert();
 			return ret;
 		}
-		WRITEdatum16(pdata, tmp);
+		_gnutls_write_datum16(pdata, tmp);
 		pdata += (2 + tmp.size);
 	}
 
diff --git a/libextra/auth_srp.c b/libextra/auth_srp.c
index f0c327a2d1..89b7b36fcb 100644
--- a/libextra/auth_srp.c
+++ b/libextra/auth_srp.c
@@ -1,5 +1,5 @@
 /*
- *      Copyright (C) 2001 Nikos Mavroyanopoulos
+ *      Copyright (C) 2001,2002 Nikos Mavroyanopoulos
  *
  * This file is part of GNUTLS.
  *
@@ -150,7 +150,7 @@ int gen_srp_server_hello(GNUTLS_STATE state, opaque * data, int data_size)
 		return GNUTLS_E_MPI_PRINT_FAILED;
 	}
 	
-	WRITEuint16( n_g, data_g);
+	_gnutls_write_uint16( n_g, data_g);
 
 	/* copy N (mod n) */
 	data_n = &data_g[2 + n_g];
@@ -160,14 +160,14 @@ int gen_srp_server_hello(GNUTLS_STATE state, opaque * data, int data_size)
 		return GNUTLS_E_MPI_PRINT_FAILED;
 	}
 	
-	WRITEuint16( n_n, data_n);
+	_gnutls_write_uint16( n_n, data_n);
 
 	/* copy the salt */
 	data_s = &data_n[2 + n_n];
 	n_s = pwd_entry->salt_size;
 	memcpy(&data_s[2], pwd_entry->salt, n_s);
 
-	WRITEuint16( n_s, data_s);
+	_gnutls_write_uint16( n_s, data_s);
 
 	ret = n_g + n_n + pwd_entry->salt_size + 6 + 1;
 	_gnutls_srp_clear_pwd_entry( pwd_entry);
@@ -203,7 +203,7 @@ int gen_srp_server_kx2(GNUTLS_STATE state, opaque ** data)
 	if (_gnutls_mpi_print( &data_b[2], &n_b, B)!=0)
 		return GNUTLS_E_MPI_PRINT_FAILED;
 
-	WRITEuint16( n_b, data_b);
+	_gnutls_write_uint16( n_b, data_b);
 
 	/* calculate u */
 	state->gnutls_key->u = _gnutls_calc_srp_u(B);
@@ -286,7 +286,7 @@ int gen_srp_client_kx0(GNUTLS_STATE state, opaque ** data)
 		return GNUTLS_E_MPI_PRINT_FAILED;
 	}
 	
-	WRITEuint16( n_a, data_a);
+	_gnutls_write_uint16( n_a, data_a);
 
 	return n_a + 2;
 }
@@ -326,7 +326,7 @@ int proc_srp_server_hello(GNUTLS_STATE state, const opaque * data, int data_size
 	i++;
 
 	DECR_LEN( data_size, 2);
-	n_g = READuint16( &data[i]);
+	n_g = _gnutls_read_uint16( &data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_g);
@@ -338,7 +338,7 @@ int proc_srp_server_hello(GNUTLS_STATE state, const opaque * data, int data_size
 	}
 
 	DECR_LEN( data_size, 2);
-	n_n = READuint16( &data[i]);
+	n_n = _gnutls_read_uint16( &data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_n);
@@ -346,7 +346,7 @@ int proc_srp_server_hello(GNUTLS_STATE state, const opaque * data, int data_size
 	i += n_n;
 	
 	DECR_LEN( data_size, 2);
-	n_s = READuint16( &data[i]);
+	n_s = _gnutls_read_uint16( &data[i]);
 	i += 2;
 
 	DECR_LEN( data_size, n_s);
@@ -389,7 +389,7 @@ int proc_srp_client_kx0(GNUTLS_STATE state, opaque * data, int data_size)
 	size_t _n_A;
 
 	DECR_LEN( data_size, 2);
-	_n_A = READuint16( &data[0]);
+	_n_A = _gnutls_read_uint16( &data[0]);
 
 	DECR_LEN( data_size, _n_A);
 	if (_gnutls_mpi_scan(&A, &data[2], &_n_A) || A == NULL) {
@@ -407,7 +407,7 @@ int proc_srp_server_kx2(GNUTLS_STATE state, opaque * data, int data_size)
 	int ret;
 	
 	DECR_LEN( data_size, 2);
-	_n_B = READuint16( &data[0]);
+	_n_B = _gnutls_read_uint16( &data[0]);
 
 	DECR_LEN( data_size, _n_B);
 	if (_gnutls_mpi_scan(&B, &data[2], &_n_B) || B==NULL) {