Added gnutls_b64_encode_fmt2() and gnutls_b64_decode_fmt2(). These functions return...

diff --git a/NEWS b/NEWS
index 73087fd448f52eb2dc8f64ba7a3bccc4c516520b..97e0d198af16658eb9b122972831bf23c05c95a9 100644 (file)
--- 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 4ee896752b7facdc51a2059431f1ec73f28e3ee6..f8e5f38ed7a610d757985712346d0f821e2a1394 100644 (file)
--- 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 74c0ca8a8189aaf8a7a96b37637cc16a66fee74e..50d97f420a97dda1eb72e324dd8d1a23b5557ffd 100644 (file)
--- 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 c849216c179edb18c65ca48e98f7ac785fc53d91..e40b14378f009a73cb880a14404992ae238063a2 100644 (file)
--- 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 d62b973eff6404594708884f5dd8a0beaa727c5d..f4a748185513ff167eda28dc81903111febe7784 100644 (file)
--- 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 88a255c1827a096fb38ff9be707a06875445190a..5beba83b05427aaca793398de46261aef0f1a3fd 100644 (file)
--- 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 380b77f795e1ad9a95b69921f487e40602c331a4..435b9b776c75b7a1560aad5ad1a6b9308f22302a 100644 (file)
--- 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()