Added gnutls_b64_encode_fmt2() and gnutls_b64_decode_fmt2(). These functions return allocated data. Cleaned up the gnutls_datum code and some of memory stuff.

7 files changed, 122 insertions, 42 deletions

diff --git a/NEWS b/NEWS
index 73087fd448..97e0d198af 100644
--- a/NEWS
+++ b/NEWS
@@ -7,6 +7,7 @@ Version ?.?.?
   function can be used to enable private (gnutls specific) cipher suites
   and compression algorithms.
 - Added check for C99 macro support by the compiler.
+- Added functions gnutls_b64_encode_fmt2() and gnutls_b64_decode_fmt2()
 
 Version 0.4.3 (23/05/2002)
 - The gnutls-extra library now compiles fine, if the opencdk library is
diff --git a/lib/gnutls_datum.c b/lib/gnutls_datum.c
index 4ee896752b..f8e5f38ed7 100644
--- a/lib/gnutls_datum.c
+++ b/lib/gnutls_datum.c
@@ -46,19 +46,22 @@ void _gnutls_write_datum8( opaque* dest, gnutls_datum dat) {
 	memcpy( &dest[1], dat.data, dat.size);
 }
 
-int gnutls_set_datum( gnutls_datum* dat, const void* data, int data_size) {
-	dat->data = gnutls_malloc(data_size);
+
+int _gnutls_set_datum_m( gnutls_datum* dat, const void* data, int data_size, 
+	ALLOC_FUNC galloc_func) {
+	dat->data = galloc_func(data_size);
 	if (dat->data==NULL) return GNUTLS_E_MEMORY_ERROR;
-	
+
 	dat->size = data_size;
 	memcpy( dat->data, data, data_size);
 	
 	return 0;
 }
 
-int gnutls_datum_append( gnutls_datum* dst, const void* data, int data_size) {
+int _gnutls_datum_append_m( gnutls_datum* dst, const void* data, int data_size,
+	REALLOC_FUNC grealloc_func) {
 
-	dst->data = gnutls_realloc(dst->data, data_size+dst->size);
+	dst->data = grealloc_func(dst->data, data_size+dst->size);
 	if (dst->data==NULL) return GNUTLS_E_MEMORY_ERROR;
 	
 	memcpy( &dst->data[dst->size], data, data_size);
@@ -67,28 +70,11 @@ int gnutls_datum_append( gnutls_datum* dst, const void* data, int data_size) {
 	return 0;
 }
 
-int gnutls_sset_datum( gnutls_datum* dat, const void* data, int data_size) {
-	dat->data = gnutls_secure_malloc(data_size);
-	if (dat->data==NULL) return GNUTLS_E_MEMORY_ERROR;
-	
-	dat->size = data_size;
-	memcpy( dat->data, data, data_size);
-	
-	return 0;
-}
-
-void gnutls_free_datum( gnutls_datum* dat) {
+void _gnutls_free_datum_m( gnutls_datum* dat, FREE_FUNC gfree_func) {
 	if (dat->data!=NULL && dat->size!=0)
-		gnutls_free( dat->data);
+		gfree_func( dat->data);
 
 	dat->data = NULL;
 	dat->size = 0;
 }
 
-void gnutls_sfree_datum( gnutls_datum* dat) {
-	if (dat->data!=NULL && dat->size!=0)
-		gnutls_free( dat->data);
-
-	dat->data = NULL;
-	dat->size = 0;
-}
diff --git a/lib/gnutls_datum.h b/lib/gnutls_datum.h
index 74c0ca8a81..50d97f420a 100644
--- a/lib/gnutls_datum.h
+++ b/lib/gnutls_datum.h
@@ -3,9 +3,16 @@ 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);
-/* uses secure_malloc */
-int gnutls_sset_datum( gnutls_sdatum* dat, const void* data, int data_size);
-void gnutls_free_datum( gnutls_datum* dat);
-void gnutls_sfree_datum( gnutls_sdatum* dat);
+int _gnutls_set_datum_m( gnutls_datum* dat, const void* data, int data_size, 
+	ALLOC_FUNC);
+#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)
+
+int _gnutls_datum_append_m( gnutls_datum* dat, const void* data, int data_size,
+	REALLOC_FUNC);
+#define gnutls_datum_append(x,y,z) _gnutls_datum_append_m(x,y,z, gnutls_realloc)
+
+void _gnutls_free_datum_m( gnutls_datum* dat, 
+	FREE_FUNC);
+#define gnutls_free_datum(x) _gnutls_free_datum_m(x, gnutls_free)
+#define gnutls_sfree_datum(x) _gnutls_free_datum_m(x, gnutls_free)
diff --git a/lib/gnutls_global.c b/lib/gnutls_global.c
index c849216c17..e40b14378f 100644
--- a/lib/gnutls_global.c
+++ b/lib/gnutls_global.c
@@ -70,11 +70,11 @@ static void dlog( const char* str) {
 #endif
 }
 
-extern void* (*gnutls_secure_malloc)(size_t);
-extern void* (*gnutls_malloc)(size_t);
-extern void (*gnutls_free)(void*);
+extern ALLOC_FUNC gnutls_secure_malloc;
+extern ALLOC_FUNC gnutls_malloc;
+extern FREE_FUNC gnutls_free;
 extern int (*_gnutls_is_secure_memory)(const void*);
-extern void* (*gnutls_realloc)(void*, size_t);
+extern REALLOC_FUNC gnutls_realloc;
 extern char* (*gnutls_strdup)(const char*);
 extern void* (*gnutls_calloc)(size_t, size_t);
 
diff --git a/lib/gnutls_mem.c b/lib/gnutls_mem.c
index d62b973eff..f4a7481855 100644
--- a/lib/gnutls_mem.c
+++ b/lib/gnutls_mem.c
@@ -23,16 +23,17 @@
 #include <gnutls_errors.h>
 #include <gnutls_num.h>
 
-void* (*gnutls_secure_malloc)(size_t) = malloc;
-void* (*gnutls_malloc)(size_t) = malloc;
+ALLOC_FUNC gnutls_secure_malloc = malloc;
+ALLOC_FUNC gnutls_malloc = malloc;
+FREE_FUNC gnutls_free = free;
+REALLOC_FUNC gnutls_realloc = realloc;
+
 void* (*gnutls_calloc)(size_t, size_t) = calloc;
-void (*gnutls_free)(void*) = free;
 char* (*gnutls_strdup)(const char*) = strdup;
 
 int _gnutls_is_secure_mem_null( const void* ign) { return 0; }
 
 int (*_gnutls_is_secure_memory)(const void*) = _gnutls_is_secure_mem_null;
-void* (*gnutls_realloc)(void*, size_t) = realloc;
 
 
 void *_gnutls_calloc(size_t nmemb, size_t size)
diff --git a/lib/gnutls_mem.h b/lib/gnutls_mem.h
index 88a255c182..5beba83b05 100644
--- a/lib/gnutls_mem.h
+++ b/lib/gnutls_mem.h
@@ -19,11 +19,17 @@ typedef void svoid; /* for functions that allocate using gnutls_secure_malloc */
 # define gnutls_afree gnutls_free
 #endif /* HAVE_ALLOCA */
 
-extern void* (*gnutls_secure_malloc)(size_t);
-extern void* (*gnutls_malloc)(size_t);
-extern void (*gnutls_free)(void*);
+typedef void* (*ALLOC_FUNC)(size_t);
+typedef void (*FREE_FUNC)(void*);
+typedef void* (*REALLOC_FUNC)(void*, size_t);
+
+extern ALLOC_FUNC gnutls_secure_malloc;
+extern ALLOC_FUNC gnutls_malloc;
+extern FREE_FUNC gnutls_free;
+
 extern int (*_gnutls_is_secure_memory)(const void*);
-extern void* (*gnutls_realloc)(void*, size_t);
+extern REALLOC_FUNC gnutls_realloc;
+
 extern void* (*gnutls_calloc)(size_t, size_t);
 extern char* (*gnutls_strdup)( const char*);
 
diff --git a/lib/x509_b64.c b/lib/x509_b64.c
index 380b77f795..435b9b776c 100644
--- a/lib/x509_b64.c
+++ b/lib/x509_b64.c
@@ -21,6 +21,7 @@
 
 #include "gnutls_int.h"
 #include "gnutls_errors.h"
+#include <gnutls_datum.h>
 
 const static uint8 b64table[64] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -278,6 +279,46 @@ int size;
 	return 0;
 }
 
+/**
+  * gnutls_b64_encode_fmt2 - 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
+  *
+  * This function will convert the given data to printable data, using the base64 
+  * encoding. This is the encoding used in PEM messages. This function will
+  * allocate (using malloc) the required memory to hold the encoded data.
+  * 
+  **/
+int gnutls_b64_encode_fmt2( const char* msg, const gnutls_datum *data, gnutls_datum* result) {
+opaque* ret;
+int size, res;
+
+	size = _gnutls_fbase64_encode( msg, data->data, data->size, &ret);
+	if (size < 0)
+		return size;
+
+	if (result==NULL) {
+		gnutls_free(ret);
+		return GNUTLS_E_INVALID_REQUEST;
+	} else {
+		if (gnutls_malloc==malloc) {
+		   result->data = ret;
+		   result->size = size;
+		} else {
+		   res = _gnutls_set_datum_m( result, ret, size, malloc);
+		   gnutls_free(ret);
+		
+		   if (res < 0) {
+		   	gnutls_assert();
+		   	return res;
+		   }
+		}
+	}
+
+	return 0;
+}
+
 
 /* decodes data and puts the result into result (localy alocated)
  * The result_size is the return value
@@ -431,6 +472,44 @@ int size;
 	return 0;
 }
 
+/**
+  * gnutls_b64_decode_fmt2 - This function will decode base64 encoded data
+  * @b64_data: contains the encoded data
+  * @result: the place where decoded data lie
+  *
+  * This function will decode the given encoded data. The decoded data
+  * will be allocated, using malloc, and stored into result.
+  * 
+  **/
+int gnutls_b64_decode_fmt2( const gnutls_datum *b64_data, gnutls_datum* result) {
+opaque* ret;
+int size, res;
+
+	size = _gnutls_fbase64_decode( b64_data->data, b64_data->size, &ret);
+	if (size < 0)
+		return size;
+
+	if (result==NULL) {
+		gnutls_free(ret);
+		return GNUTLS_E_INVALID_REQUEST;
+	} else {
+		if (gnutls_malloc==malloc) {
+			result->data = ret;
+			result->size = size;
+		} else {
+			res = _gnutls_set_datum_m( result, ret, size, malloc);
+			gnutls_free( ret);
+			
+			if (res < 0) {
+				gnutls_assert();
+				return res;
+			}
+		}
+	}
+
+	return 0;
+}
+
 
 #ifdef B64_TEST
 int main()