receive buffer is now dynamic.

6 files changed, 36 insertions, 19 deletions

diff --git a/lib/auth_dhe_rsa.c b/lib/auth_dhe_rsa.c
index dd76e4a26f..cbbc455701 100644
--- a/lib/auth_dhe_rsa.c
+++ b/lib/auth_dhe_rsa.c
@@ -166,6 +166,7 @@ static int gen_dhe_rsa_server_kx(GNUTLS_STATE state, opaque ** data)
 
 	*data = gnutls_realloc( *data, data_size+signature.size+2);
 	if (*data==NULL) {
+		gnutls_free_datum( &signature);
 		gnutls_assert();
 		return GNUTLS_E_MEMORY_ERROR;
 	}
@@ -173,6 +174,8 @@ static int gen_dhe_rsa_server_kx(GNUTLS_STATE state, opaque ** data)
 	WRITEdatum16( &(*data)[data_size], signature);
 	data_size += signature.size+2;
 
+	gnutls_free_datum( &signature);
+
 	return data_size;
 }
 
diff --git a/lib/gnutls_buffers.c b/lib/gnutls_buffers.c
index e33ac69c59..61106915d8 100644
--- a/lib/gnutls_buffers.c
+++ b/lib/gnutls_buffers.c
@@ -264,8 +264,8 @@ int ret, sum;
 }
 
 
-void _gnutls_read_clear_buffer( GNUTLS_STATE state) {
-	state->gnutls_internals.recv_buffer_data_size = 0;
+void _gnutls_clear_read_buffer( GNUTLS_STATE state) {
+	state->gnutls_internals.recv_buffer.size = 0;
 }
                   	
 /* This function is like recv(with MSG_PEEK). But it does not return -1 on error.
@@ -289,7 +289,8 @@ ssize_t _gnutls_read_buffered( int fd, GNUTLS_STATE state, opaque **iptr, size_t
 
 	*iptr = NULL;
 
-	if ( sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0 || (state->gnutls_internals.recv_buffer_data_size+sizeOfPtr) > MAX_RECV_SIZE) {
+	if ( sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0 
+	|| (state->gnutls_internals.recv_buffer.size+sizeOfPtr) > MAX_RECV_SIZE) {
 		gnutls_assert(); /* internal error */
 		return GNUTLS_E_INVALID_PARAMETERS;
 	}
@@ -302,15 +303,11 @@ ssize_t _gnutls_read_buffered( int fd, GNUTLS_STATE state, opaque **iptr, size_t
 		&& state->gnutls_internals.have_peeked_data==0)
 		recvlowat = 0;
 
-	buf = state->gnutls_internals.recv_buffer_data;
-	buf_pos = state->gnutls_internals.recv_buffer_data_size;
-
-	*iptr = buf;
 	
 	/* calculate the actual size, ie. get the minimum of the
 	 * buffered data and the requested data.
 	 */
-	min = GMIN( state->gnutls_internals.recv_buffer_data_size, sizeOfPtr);
+	min = GMIN( state->gnutls_internals.recv_buffer.size, sizeOfPtr);
 	if ( min > 0) {
 		/* if we have enough buffered data
 		 * then just return them.
@@ -324,7 +321,19 @@ ssize_t _gnutls_read_buffered( int fd, GNUTLS_STATE state, opaque **iptr, size_t
 	 * receive in order to return the requested data.
 	 */
 	recvdata = sizeOfPtr - min;
+	
+	/* Allocate the data required to store the new packet.
+	 */
+	state->gnutls_internals.recv_buffer.data = gnutls_realloc_fast(
+		state->gnutls_internals.recv_buffer.data, recvdata+state->gnutls_internals.recv_buffer.size);
+	if ( state->gnutls_internals.recv_buffer.data==NULL) {
+		gnutls_assert();
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 
+	buf_pos = state->gnutls_internals.recv_buffer.size;
+	buf = state->gnutls_internals.recv_buffer.data;
+	*iptr = buf;
 
 	/* READ DATA - but leave RCVLOWAT bytes in the kernel buffer.
 	 */
@@ -346,10 +355,10 @@ ssize_t _gnutls_read_buffered( int fd, GNUTLS_STATE state, opaque **iptr, size_t
 	/* copy fresh data to our buffer.
 	 */
 	if (ret > 0)
-		state->gnutls_internals.recv_buffer_data_size += ret;
+		state->gnutls_internals.recv_buffer.size += ret;
 
 
-	buf_pos = state->gnutls_internals.recv_buffer_data_size;
+	buf_pos = state->gnutls_internals.recv_buffer.size;
 	
 	/* This is hack in order for select to work. Just leave recvlowat data,
 	 * into the kernel buffer (using a read with MSG_PEEK), thus making
@@ -371,7 +380,7 @@ ssize_t _gnutls_read_buffered( int fd, GNUTLS_STATE state, opaque **iptr, size_t
 
 		if (ret2 > 0) {
 			state->gnutls_internals.have_peeked_data = 1;
-			state->gnutls_internals.recv_buffer_data_size += ret2;
+			state->gnutls_internals.recv_buffer.size += ret2;
 
 		}
 	}
@@ -394,7 +403,7 @@ ssize_t _gnutls_read_buffered( int fd, GNUTLS_STATE state, opaque **iptr, size_t
 		return 0;
 	}
 
-	ret = state->gnutls_internals.recv_buffer_data_size;
+	ret = state->gnutls_internals.recv_buffer.size;
 
 	if ((ret > 0) && (ret < sizeOfPtr)) {
 		/* Short Read */
@@ -547,7 +556,6 @@ ssize_t _gnutls_handshake_send_int( SOCKET fd, GNUTLS_STATE state, ContentType t
 		 * the data field so send_int() will proceed normally.
 		 */
 		return _gnutls_flush( fd, state);
-//		return gnutls_send_int( fd, state, type, htype, &sdata, 1);
 	}
 
 	left = n;
@@ -622,7 +630,6 @@ int gnutls_insert_to_handshake_buffer( GNUTLS_STATE state, char *data, int lengt
 	state->gnutls_internals.hash_buffer.data =
 		    gnutls_realloc_fast(state->gnutls_internals.hash_buffer.data,
 			   state->gnutls_internals.hash_buffer.size);
-			   
 	if (state->gnutls_internals.hash_buffer.data == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_MEMORY_ERROR;
diff --git a/lib/gnutls_buffers.h b/lib/gnutls_buffers.h
index 9f096572f0..6f31c714ef 100644
--- a/lib/gnutls_buffers.h
+++ b/lib/gnutls_buffers.h
@@ -22,7 +22,7 @@ int gnutls_insert_to_data_buffer(ContentType type, GNUTLS_STATE state, char *dat
 int gnutls_get_data_buffer_size(ContentType type, GNUTLS_STATE state);
 int gnutls_get_data_buffer(ContentType type, GNUTLS_STATE state, char *data, int length);
 ssize_t _gnutls_read_buffered(int fd, GNUTLS_STATE, opaque **iptr, size_t n, ContentType);
-void _gnutls_read_clear_buffer( GNUTLS_STATE);
+void _gnutls_clear_read_buffer( GNUTLS_STATE);
 int _gnutls_clear_peeked_data( SOCKET cd, GNUTLS_STATE state);
 
 ssize_t _gnutls_write_buffered(int fd, GNUTLS_STATE, const void *iptr, size_t n );
diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index 58fb0d7008..8e47874fed 100644
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -371,8 +371,7 @@ typedef struct {
 					/* this buffer holds a record packet -mostly used for
 					 * non blocking IO.
 					 */
-	opaque				recv_buffer_data[MAX_RECV_SIZE];
-	int				recv_buffer_data_size;
+	gnutls_datum			recv_buffer;
 	gnutls_datum			send_buffer; /* holds cached data
 					* for the gnutls_write_buffered()
 					* function.
diff --git a/lib/gnutls_mem.c b/lib/gnutls_mem.c
index 6401684784..9cde853528 100644
--- a/lib/gnutls_mem.c
+++ b/lib/gnutls_mem.c
@@ -107,6 +107,7 @@ void *gnutls_realloc(void *_ptr, size_t size)
 
 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.
diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index 2ede69d253..31e42f707b 100644
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -95,7 +95,7 @@ int gnutls_init(GNUTLS_STATE * state, ConnectionEnd con_end)
 	(*state)->gnutls_internals.resumable = RESUME_TRUE;
 
 	gnutls_set_protocol_priority( *state, GNUTLS_TLS1, 0); /* default */
-
+	
 	(*state)->gnutls_key = gnutls_calloc(1, sizeof(struct GNUTLS_KEY_INT));
 	if ( (*state)->gnutls_key == NULL) {
 		gnutls_free( *state);
@@ -110,6 +110,12 @@ int gnutls_init(GNUTLS_STATE * state, ConnectionEnd con_end)
 
 	gnutls_set_max_handshake_data_buffer_size( (*state), MAX_HANDSHAKE_DATA_BUFFER_SIZE);
 
+	/* Allocate a minimum size for recv_data 
+	 * This is allocated in order to avoid small messages, makeing
+	 * the receive procedure slow.
+	 */
+	(*state)->gnutls_internals.recv_buffer.data = gnutls_malloc(256);
+
 	/* everything else not initialized here is initialized
 	 * as NULL or 0. This is why calloc is used.
 	 */
@@ -143,6 +149,7 @@ int gnutls_deinit(GNUTLS_STATE state)
 	gnutls_sfree_datum(&state->connection_state.read_mac_secret);
 	gnutls_sfree_datum(&state->connection_state.write_mac_secret);
 
+	GNUTLS_FREE(state->gnutls_internals.recv_buffer.data);
 	GNUTLS_FREE(state->gnutls_internals.buffer.data);
 	GNUTLS_FREE(state->gnutls_internals.buffer_handshake.data);
 	GNUTLS_FREE(state->gnutls_internals.hash_buffer.data);
@@ -751,7 +758,7 @@ ssize_t gnutls_recv_int(SOCKET cd, GNUTLS_STATE state, ContentType type, Handsha
 /* ok now we are sure that we can read all the data - so
  * move on !
  */
-	_gnutls_read_clear_buffer( state);
+	_gnutls_clear_read_buffer( state);
 	ciphertext = &recv_data[header_size];
 	
 	/* decrypt the data we got