*** empty log message ***gnutls_0_2_9

6 files changed, 141 insertions, 101 deletions

diff --git a/NEWS b/NEWS
index 1559131a75..959f4186e1 100644
--- a/NEWS
+++ b/NEWS
@@ -1,4 +1,4 @@
-Version 0.3.0
+Version 0.2.9 (27/10/2001)
 - AUTH_INFO types and structures were moved to library internals
 - AUTH_FAILED is no longer returned in SRP authentication
   (any fatal error in SRP means auth failed)
diff --git a/configure.in b/configure.in
index e625c567e1..360e14ce5d 100644
--- a/configure.in
+++ b/configure.in
@@ -10,8 +10,8 @@ AC_DEFINE_UNQUOTED(T_VENDOR, "$target_vendor")
 AC_DEFINE_UNQUOTED(T_OS, "$target_os")
 
 GNUTLS_MAJOR_VERSION=0
-GNUTLS_MINOR_VERSION=3
-GNUTLS_MICRO_VERSION=0
+GNUTLS_MINOR_VERSION=2
+GNUTLS_MICRO_VERSION=9
 GNUTLS_VERSION=$GNUTLS_MAJOR_VERSION.$GNUTLS_MINOR_VERSION.$GNUTLS_MICRO_VERSION
 
 AC_DEFINE_UNQUOTED(GNUTLS_VERSION, "$GNUTLS_VERSION")
diff --git a/lib/gnutls_db.c b/lib/gnutls_db.c
index 1dd42e71cc..2e79ceeefd 100644
--- a/lib/gnutls_db.c
+++ b/lib/gnutls_db.c
@@ -142,6 +142,9 @@ time_t timestamp;
 
 }
 
+/* The format of storing data is:
+ * SECURITY_PARAMETERS + AUTH_INFO_SIZE + AUTH_INFO
+ */
 int _gnutls_server_register_current_session( GNUTLS_STATE state)
 {
 #ifdef HAVE_LIBGDBM
@@ -164,13 +167,16 @@ int ret = 0;
 		return GNUTLS_E_DB_ERROR;
 
 /* allocate space for data */
-	content.dsize = sizeof(SecurityParameters) + state->gnutls_key->auth_info_size;
+	content.dsize = sizeof(SecurityParameters) + state->gnutls_key->auth_info_size
+		+ sizeof(state->gnutls_key->auth_info_size);
 	content.dptr = gnutls_malloc( content.dsize);
 	if (content.dptr==NULL) return GNUTLS_E_MEMORY_ERROR;
 
 /* copy data */
 	memcpy( content.dptr, (void*)&state->security_parameters, sizeof(SecurityParameters));
-	memcpy( &content.dptr[sizeof(SecurityParameters)], state->gnutls_key->auth_info,  state->gnutls_key->auth_info_size);
+	memcpy( &content.dptr[sizeof(SecurityParameters)], &state->gnutls_key->auth_info_size,  sizeof(state->gnutls_key->auth_info_size));
+	memcpy( &content.dptr[sizeof(state->gnutls_key->auth_info_size)+sizeof(SecurityParameters)], 
+		state->gnutls_key->auth_info,  state->gnutls_key->auth_info_size);
 
 	dbf = gdbm_open(GNUTLS_DBNAME, 0, GDBM_WRITER, 0600, NULL);
 	if (dbf==NULL) {
diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index d346e184e9..4cfcce4b78 100644
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -391,7 +391,7 @@ typedef struct {
 						* if none.
 						*/
 	/* this is the highest version available
-	 * to the peer.
+	 * to the peer. (advertized version)
 	 */
 	uint8				adv_version_major;
 	uint8				adv_version_minor;
diff --git a/lib/gnutls_mem.c b/lib/gnutls_mem.c
index 7bb9a6b376..4f58c76f5b 100644
--- a/lib/gnutls_mem.c
+++ b/lib/gnutls_mem.c
@@ -24,7 +24,8 @@
 
 #ifdef USE_DMALLOC
 
-int _gnutls_is_secure_memory(const void* ign) {
+int _gnutls_is_secure_memory(const void *ign)
+{
 	return 0;
 }
 
@@ -33,151 +34,173 @@ int _gnutls_is_secure_memory(const void* ign) {
 /* #define MALLOC_DEBUG */
 # define EXTRA_SIZE sizeof(size_t)+1
 
-int _gnutls_is_secure_memory(const svoid* mem) {
-        return *((opaque*)mem-1);
+int _gnutls_is_secure_memory(const svoid * mem)
+{
+	return *((opaque *) mem - 1);
 }
 
-void* gnutls_malloc( size_t size) {
-opaque* ret;
-	if (size==0) return NULL;
-	
-	ret = malloc( size+EXTRA_SIZE);
-	if (ret==NULL) return ret;
+void *gnutls_malloc(size_t size)
+{
+	opaque *ret;
+	if (size == 0)
+		return NULL;
+
+	ret = malloc(size + EXTRA_SIZE);
+	if (ret == NULL)
+		return ret;
+
+	*((int *) ret) = size;
+	ret[sizeof(size_t)] = 0;	/* not secure */
 
-	*((int*)ret) = size;
-	ret[sizeof(size_t)] = 0; /* not secure */
-	
 	ret += EXTRA_SIZE;
 
 #ifdef MALLOC_DEBUG
-	_gnutls_log("Allocated: %x with %d bytes\n", ret, _gnutls_malloc_ptr_size(ret));
+	_gnutls_log("Allocated: %x with %d bytes\n", ret,
+		    _gnutls_malloc_ptr_size(ret));
 #endif
 
 	return ret;
-	
+
 }
 
-void* gnutls_calloc( size_t nmemb, size_t size) {
-void* ret;
-	ret = gnutls_malloc( size);
-	if (ret==NULL) return ret;
-	
-	memset( ret, 0, size);
-	
+void *gnutls_calloc(size_t nmemb, size_t size)
+{
+	void *ret;
+	ret = gnutls_malloc(size);
+	if (ret == NULL)
+		return ret;
+
+	memset(ret, 0, size);
+
 	return ret;
 }
 
-size_t _gnutls_malloc_ptr_size( void* _ptr) {
-opaque* ptr = _ptr;
+size_t _gnutls_malloc_ptr_size(void *_ptr)
+{
+	opaque *ptr = _ptr;
 
-	if (_ptr==NULL) return 0;
-	
-	return *( (int*)((opaque*)ptr-sizeof(size_t)-1));
+	if (_ptr == NULL)
+		return 0;
+
+	return *((int *) ((opaque *) ptr - sizeof(size_t) - 1));
 }
 
-void* gnutls_realloc( void* ptr, size_t size) {
-void* ret;
-	ret = gnutls_malloc( size);
-	if (ret==NULL) return ret;
-	
-	if (ptr!=NULL) {
-		memcpy( ret, ptr, GMIN( _gnutls_malloc_ptr_size(ptr), size));
-		gnutls_free(ptr);
-	}
+void *gnutls_realloc(void *_ptr, size_t size)
+{
+	opaque *ret;
+	opaque* ptr = _ptr;
 	
+	if (ptr!=NULL)
+		ptr -= EXTRA_SIZE;
+
+	ret = realloc(ptr, size + EXTRA_SIZE);
+	if (ret == NULL)
+		return ret;
+
+	*((int *) ret) = size;
+	ret[sizeof(size_t)] = 0;	/* not secure */
+
+	ret += EXTRA_SIZE;
+
 	return ret;
 }
 
-void* gnutls_realloc_fast( void* ptr, size_t size) {
-void* ret;
-	if ( ptr != NULL && size <= _gnutls_malloc_ptr_size(ptr)) {
+void *gnutls_realloc_fast(void *ptr, size_t size)
+{
+	if (ptr != NULL && size <= _gnutls_malloc_ptr_size(ptr)) {
 		/* do nothing, just return the pointer.
-		 * It's much faster.
+		   * It's much faster.
 		 */
 		return ptr;
 	}
-	ret = gnutls_malloc( size);
-	if (ret==NULL) return ret;
-	
-	if (ptr!=NULL) {
-		memcpy( ret, ptr, GMIN( _gnutls_malloc_ptr_size(ptr), size));
-		gnutls_free(ptr);
-	}
-	
-	return ret;
+	return gnutls_realloc(ptr, size);
 }
 
-void gnutls_free( void* _ptr) {
-opaque* ptr = _ptr;
-        
-        if (_ptr==NULL) return;
-        
+
+void gnutls_free(void *_ptr)
+{
+	opaque *ptr = _ptr;
+
+	if (_ptr == NULL)
+		return;
+
 	ptr -= EXTRA_SIZE;
 
 #ifdef MALLOC_DEBUG
-	_gnutls_log("Freed: %x with %d bytes\n", _ptr, _gnutls_malloc_ptr_size(_ptr));
+	_gnutls_log("Freed: %x with %d bytes\n", _ptr,
+		    _gnutls_malloc_ptr_size(_ptr));
 #endif
-	free( ptr);
+	free(ptr);
 }
 
-svoid* secure_malloc( size_t size) {
-opaque* ret;
-	ret = gnutls_malloc( size);
-	if (ret==NULL) return ret;
-	
-	*((opaque*)ret-1) = 1; /* secure mem */
-	
+svoid *secure_malloc(size_t size)
+{
+	opaque *ret;
+	ret = gnutls_malloc(size);
+	if (ret == NULL)
+		return ret;
+
+	*((opaque *) ret - 1) = 1;	/* secure mem */
+
 	return ret;
-	
+
 }
 
-svoid* secure_calloc( size_t nmemb, size_t size) {
-svoid* ret;
-	ret = secure_malloc( size);
-	if (ret==NULL) return ret;
-	
-	memset( ret, 0, size);
-	
+svoid *secure_calloc(size_t nmemb, size_t size)
+{
+	svoid *ret;
+	ret = secure_malloc(size);
+	if (ret == NULL)
+		return ret;
+
+	memset(ret, 0, size);
+
 	return ret;
 }
 
-size_t _secure_ptr_size( svoid* ptr) {
-	return _gnutls_malloc_ptr_size( ptr);
+size_t _secure_ptr_size(svoid * ptr)
+{
+	return _gnutls_malloc_ptr_size(ptr);
 }
 
-svoid* secure_realloc( svoid* ptr, size_t size) {
-svoid* ret;
-	if ( ptr != NULL && size <= _secure_ptr_size(ptr)) {
+svoid *secure_realloc(svoid * ptr, size_t size)
+{
+	svoid *ret;
+	if (ptr != NULL && size <= _secure_ptr_size(ptr)) {
 		/* do not do realloc.
 		 * return the previous pointer.
 		 */
 		return ptr;
 	}
-	ret = secure_malloc( size);
-	if (ret==NULL) return ret;
+	ret = secure_malloc(size);
+	if (ret == NULL)
+		return ret;
 
-	if (ptr!=NULL) {
-		memcpy( ret, ptr, GMIN( _secure_ptr_size(ptr), size));
+	if (ptr != NULL) {
+		memcpy(ret, ptr, GMIN(_secure_ptr_size(ptr), size));
 		secure_free(ptr);
 	}
-		
+
 	return ret;
 }
 
-void secure_free( svoid* ptr) {
-        memset( ptr, 0, _secure_ptr_size( ptr));
-	gnutls_free( ptr);
+void secure_free(svoid * ptr)
+{
+	memset(ptr, 0, _secure_ptr_size(ptr));
+	gnutls_free(ptr);
 }
 
-char* gnutls_strdup( const char* s) {
-int size = strlen(s);
-char* ret;
- 
-	ret = gnutls_malloc(size+1); /* hold null */
-	if (ret==NULL) return ret;
-	
-	strcpy( ret, s);
-	
+char *gnutls_strdup(const char *s)
+{
+	int size = strlen(s);
+	char *ret;
+
+	ret = gnutls_malloc(size + 1);	/* hold null */
+	if (ret == NULL)
+		return ret;
+
+	strcpy(ret, s);
+
 	return ret;
 }
-#endif /* USE_DMALLOC */
+#endif				/* USE_DMALLOC */
diff --git a/lib/gnutls_session.c b/lib/gnutls_session.c
index ed0ea76e34..ee6c6de7b9 100644
--- a/lib/gnutls_session.c
+++ b/lib/gnutls_session.c
@@ -45,7 +45,10 @@ int gnutls_get_current_session( GNUTLS_STATE state, opaque* session, int *sessio
 		return 0;
 	}
 	memcpy( session, &state->security_parameters, sizeof(SecurityParameters));
-	memcpy( &session[sizeof(SecurityParameters)], state->gnutls_key->auth_info, state->gnutls_key->auth_info_size);
+/*	memcpy( &session[sizeof(SecurityParameters)], state->gnutls_key->auth_info, state->gnutls_key->auth_info_size);*/
+	memcpy( &session[sizeof(SecurityParameters)], &state->gnutls_key->auth_info_size,  sizeof(state->gnutls_key->auth_info_size));
+	memcpy( &session[sizeof(state->gnutls_key->auth_info_size)+sizeof(SecurityParameters)], 
+		state->gnutls_key->auth_info,  state->gnutls_key->auth_info_size);
 
 	return 0;
 }
@@ -94,6 +97,10 @@ int gnutls_set_current_session( GNUTLS_STATE state, opaque* session, int session
 	int auth_info_size = session_size - sizeof(SecurityParameters);
 	int timestamp = time(0);
 	SecurityParameters sp;
+
+	if (auth_info_size > sizeof(state->gnutls_key->auth_info_size)) { /* have more data */
+		auth_info_size = *((int*)&session[sizeof(SecurityParameters)]);	
+	}
 	
 	if (session_size < sizeof(SecurityParameters))
 		return GNUTLS_E_UNIMPLEMENTED_FEATURE;
@@ -106,7 +113,11 @@ int gnutls_set_current_session( GNUTLS_STATE state, opaque* session, int session
 		if (auth_info_size > 0) {
 			state->gnutls_key->auth_info_size = auth_info_size;
 			state->gnutls_key->auth_info = gnutls_malloc(auth_info_size);
-			memcpy( state->gnutls_key->auth_info, &session[sizeof(SecurityParameters)], auth_info_size);
+			if (state->gnutls_key->auth_info==NULL) {
+				gnutls_assert();
+				return GNUTLS_E_MEMORY_ERROR;
+			}
+			memcpy( state->gnutls_key->auth_info, &session[sizeof(SecurityParameters)+sizeof(state->gnutls_key->auth_info_size)], auth_info_size);
 		} else { /* set to null */
 			state->gnutls_key->auth_info_size = 0;
 			state->gnutls_key->auth_info = NULL;