changed gnutls_read() semantics

diff --git a/NEWS b/NEWS
index de77ad5723c22210718aa46b04d89a46750428f0..62989b5b63988047a889157385fe4183ee003f11 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -7,6 +7,7 @@ Version 0.1.9
 - (Error) message handling has changed
 - Better Protocol Version handling
 - Added x509 Certificate Verification
+- gnutls_read() semantics are now closer to read(2)
 
 Version 0.1.4 (22/06/2001)
 - Corrected (srp) base64 encoding.

diff --git a/lib/gnutls.h.in b/lib/gnutls.h.in
index 54353c4be7fdd21683fa99d7563bcb532ed02658..471bfc9973eb62632a1f8b4a2ff309a6f46d1b5e 100644 (file)
--- a/lib/gnutls.h.in
+++ b/lib/gnutls.h.in
@@ -234,5 +234,8 @@ int gnutls_set_x509_trust( X509PKI_CREDENTIALS res, char* CAFILE, char* CRLFILE)
 int gnutls_global_init();
 void gnutls_global_deinit();
 
+void gnutls_set_recv_func( ssize_t (*recv_func)(SOCKET, void*, size_t, int));
+void gnutls_set_send_func( ssize_t (*send_func)(SOCKET, const void*, size_t, int));
+
 
 /* error codes appended here */

diff --git a/lib/gnutls_buffers.c b/lib/gnutls_buffers.c
index f368e88a0c6b8630d00f66a82990ae5b4d2a26c5..e7700eb72bf9bcd8c78c500f288ac6fe6f3b436e 100644 (file)
--- a/lib/gnutls_buffers.c
+++ b/lib/gnutls_buffers.c
@@ -24,8 +24,8 @@
  # include <errno.h>
 #endif
 
-extern ssize_t (*recv_func)( SOCKET, void*, size_t, int);
-extern ssize_t (*send_func)( SOCKET,const void*, size_t, int);
+extern ssize_t (*_gnutls_recv_func)( SOCKET, void*, size_t, int);
+extern ssize_t (*_gnutls_send_func)( SOCKET,const void*, size_t, int);
 
 
 int gnutls_insertDataBuffer(ContentType type, GNUTLS_STATE state, char *data, int length)
@@ -145,7 +145,7 @@ ssize_t _gnutls_Read(int fd, void *iptr, size_t sizeOfPtr, int flag)
 
        left = sizeOfPtr;
        while (left > 0) {
-               i = recv_func(fd, &ptr[i], left, flag);
+               i = _gnutls_recv_func(fd, &ptr[i], left, flag);
                if (i < 0) {
                        return (0-errno);
                } else {
@@ -203,7 +203,7 @@ ssize_t _gnutls_Write(int fd, const void *iptr, size_t n, int flags)
 #endif
        left = n;
        while (left > 0) {
-               i = send(fd, &ptr[i], left, flags);
+               i = _gnutls_send_func(fd, &ptr[i], left, flags);
                if (i == -1) {
                        return (0-errno);
                }

diff --git a/lib/gnutls_errors.c b/lib/gnutls_errors.c
index 5a147fe75957a322bba412db30fae82fb8d424ae..b8fae8fd438856b281405d6b44263afccc2a2fb3 100644 (file)
--- a/lib/gnutls_errors.c
+++ b/lib/gnutls_errors.c
@@ -50,7 +50,6 @@ static gnutls_error_entry error_algorithms[] = {
        GNUTLS_ERROR_ENTRY( GNUTLS_E_RECEIVED_MORE_DATA, 1),
        GNUTLS_ERROR_ENTRY( GNUTLS_E_UNEXPECTED_PACKET, 1),
        GNUTLS_ERROR_ENTRY( GNUTLS_E_WARNING_ALERT_RECEIVED, 0),
-       GNUTLS_ERROR_ENTRY( GNUTLS_E_CLOSURE_ALERT_RECEIVED, 1),
        GNUTLS_ERROR_ENTRY( GNUTLS_E_ERROR_IN_FINISHED_PACKET, 1),
        GNUTLS_ERROR_ENTRY( GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET, 1),
        GNUTLS_ERROR_ENTRY( GNUTLS_E_UNKNOWN_KX_ALGORITHM, 1),

diff --git a/lib/gnutls_errors_int.h b/lib/gnutls_errors_int.h
index e89a2c719483467a96ac73e7380262f749b20e3a..01ddd5ce520a0dc81c3fa9e7f5855c0f27b6ceb9 100644 (file)
--- a/lib/gnutls_errors_int.h
+++ b/lib/gnutls_errors_int.h
@@ -14,7 +14,6 @@
 #define GNUTLS_E_RECEIVED_MORE_DATA -14
 #define GNUTLS_E_UNEXPECTED_PACKET -15
 #define GNUTLS_E_WARNING_ALERT_RECEIVED -16
-#define GNUTLS_E_CLOSURE_ALERT_RECEIVED -17
 #define GNUTLS_E_ERROR_IN_FINISHED_PACKET -18
 #define GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET -19
 #define GNUTLS_E_UNKNOWN_KX_ALGORITHM -20

diff --git a/lib/gnutls_global.c b/lib/gnutls_global.c
index 6d19ef1af29cebb53871cdf2032a2aafb26b014c..f21a199152607fac29a5062cea9b0b02f7632560 100644 (file)
--- a/lib/gnutls_global.c
+++ b/lib/gnutls_global.c
@@ -30,8 +30,8 @@ extern const static_asn pkcs1_asn1_tab[];
 extern const static_asn pkix_asn1_tab[];
 
 static void* old_sig_handler;
-ssize_t (*recv_func)( SOCKET, void*, size_t, int);
-ssize_t (*send_func)( SOCKET,const void*, size_t, int);
+ssize_t (*_gnutls_recv_func)( SOCKET, void*, size_t, int);
+ssize_t (*_gnutls_send_func)( SOCKET,const void*, size_t, int);
 
 static node_asn *PKIX1_ASN;
 static node_asn *PKCS1_ASN;
@@ -44,6 +44,37 @@ node_asn* _gnutls_get_pkcs() {
        return PKCS1_ASN;
 }
 
+/**
+  * gnutls_set_recv_func - This function sets the recv() function
+  * @(*recv_func): it's a recv(2) like function
+  *
+  * This is the function were you set the recv() function gnutls
+  * is going to use. Normaly you may not use this function since
+  * the default (recv(2)) will probably be ok, unless you use
+  * some external library (like gnu pthreads), which provide
+  * a front end to this function. This function should be
+  * called once and after gnutls_global_init().
+  *
+  **/
+void gnutls_set_recv_func( ssize_t (*recv_func)(SOCKET,void*,size_t,int)) {
+       _gnutls_recv_func = recv_func;
+}
+
+/**
+  * gnutls_set_send_func - This function sets the send() function
+  * @(*send_func): it's a send(2) like function
+  *
+  * This is the function were you set the send() function gnutls
+  * is going to use. Normaly you may not use this function since
+  * the default (send(2)) will probably be ok, unless you use
+  * some external library (like gnu pthreads), which provide
+  * a front end to this function. This function should be
+  * called once and after gnutls_global_init().
+  **/
+void gnutls_set_send_func( ssize_t (*send_func)(SOCKET, const void*,size_t,int)) {
+       _gnutls_send_func = send_func;
+}
+
 int gnutls_is_secure_memory(const void* mem) {
        return 0;
 }
@@ -71,8 +102,8 @@ int gnutls_global_init()
 
        /* set default recv/send functions
         */
-       recv_func = recv;
-       send_func = send;
+       _gnutls_recv_func = recv;
+       _gnutls_send_func = send;
 
        /* initialize parser 
         * This should not deal with files in the final

diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index 6b209440596a2a1667ca17b64068bc6c6d2b082a..82491ba7c6958249175495385a13863886394847 100644 (file)
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -560,9 +560,9 @@ ssize_t gnutls_recv_int(SOCKET cd, GNUTLS_STATE state, ContentType type, Handsha
                return ret;
        }
 
-       if (state->gnutls_internals.valid_connection == VALID_FALSE) {
-               gnutls_assert();
-               return GNUTLS_E_INVALID_SESSION;
+       if (state->gnutls_internals.valid_connection == VALID_FALSE || sizeofdata==0) {
+               return 0; /* EOF */
+/*             return GNUTLS_E_INVALID_SESSION; */
        }
 
        /* in order for GNUTLS_E_AGAIN to be returned the socket
@@ -774,7 +774,8 @@ ssize_t gnutls_recv_int(SOCKET cd, GNUTLS_STATE state, ContentType type, Handsha
                                
                                gnutls_free(tmpdata);
                                
-                               return GNUTLS_E_CLOSURE_ALERT_RECEIVED;
+                               return 0; /* EOF */
+/*                             return GNUTLS_E_CLOSURE_ALERT_RECEIVED; */
                        } else {
                        
                                /* if the alert is FATAL or WARNING
@@ -1011,6 +1012,8 @@ ssize_t gnutls_send(SOCKET cd, GNUTLS_STATE state, const void *data, size_t size
   * The only acceptable flag is currently MSG_DONTWAIT. In that case,
   * if the socket is set to non blocking IO it will return GNUTLS_E_AGAIN,
   * if there are no data in the socket. 
+  * Returns the number of bytes received, zero on EOF, or
+  * a negative error code.
   **/
 ssize_t gnutls_recv(SOCKET cd, GNUTLS_STATE state, void *data, size_t sizeofdata, int flags) {
        return gnutls_recv_int( cd, state, GNUTLS_APPLICATION_DATA, -1, data, sizeofdata, flags);
@@ -1039,6 +1042,8 @@ ssize_t gnutls_write(SOCKET cd, GNUTLS_STATE state, const void *data, size_t siz
   *
   * This function has the same semantics as read() has. The only
   * difference is that is accepts a GNUTLS state. 
+  * Returns the number of bytes received, zero on EOF, or
+  * a negative error code.
   **/
 ssize_t gnutls_read(SOCKET cd, GNUTLS_STATE state, void *data, size_t sizeofdata) {
        return gnutls_recv_int( cd, state, GNUTLS_APPLICATION_DATA, -1, data, sizeofdata, 0);

diff --git a/src/cli.c b/src/cli.c
index c7bd2268413b06a927f99ce65a8bd3a720ddab05..61d0b9ecc350736a3ed432dffc55c63fd0bd6a0d 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -287,8 +287,8 @@ int main(int argc, char** argv)
                        ret = gnutls_read(sd, state, buffer, MAX_BUF);
                        /* remove new line */
 
-                       if (gnutls_is_fatal_error(ret) == 1) {
-                               if (ret == GNUTLS_E_CLOSURE_ALERT_RECEIVED || ret == GNUTLS_E_INVALID_SESSION) {
+                       if (gnutls_is_fatal_error(ret) == 1 || ret==0) {
+                               if (ret == 0) {
                                        printf("- Peer has closed the GNUTLS connection\n");
                                        break;
                                } else {

diff --git a/src/serv.c b/src/serv.c
index 4fd23dc1dd4313d3299c739c74cb173d02315f55..524fbb052943f0c0f57df4f78c21bd1d5b56ccce 100644 (file)
--- a/src/serv.c
+++ b/src/serv.c
@@ -94,6 +94,8 @@ GNUTLS_STATE initialize_state()
         */
        gnutls_set_cipher_priority(state, GNUTLS_NULL_CIPHER, 
                                   GNUTLS_RIJNDAEL_CBC, GNUTLS_3DES_CBC, GNUTLS_ARCFOUR, 0);
+       gnutls_set_cipher_priority(state, GNUTLS_NULL_CIPHER, 
+                                  GNUTLS_RIJNDAEL_CBC, GNUTLS_3DES_CBC, 0);
        gnutls_set_compression_priority(state, GNUTLS_ZLIB, GNUTLS_NULL_COMPRESSION, 0);
        gnutls_set_kx_priority(state, GNUTLS_KX_DHE_RSA, GNUTLS_KX_RSA, GNUTLS_KX_SRP,
                               GNUTLS_KX_DH_ANON, 0);
@@ -186,8 +188,8 @@ void peer_print_info(int cd, GNUTLS_STATE state)
         * print the hostname he connected to.
         */
        if (gnutls_ext_get_dnsname(state)!=NULL) {
-               printf("\n<p>DNSNAME: ");
-               printf("<b>%s</b></p>\n", gnutls_ext_get_dnsname(state));
+               sprintf(tmp2, "\n<p>DNSNAME: ");
+               sprintf(tmp2, "<b>%s</b></p>\n", gnutls_ext_get_dnsname(state));
        }
 
        /* print srp specific data */
@@ -362,8 +364,8 @@ int main(int argc, char **argv)
                        bzero(buffer, MAX_BUF + 1);
                        ret = read_request(sd, state, buffer, MAX_BUF, (http==0)?1:2);
 
-                       if (gnutls_is_fatal_error(ret) == 1) {
-                               if (ret == GNUTLS_E_CLOSURE_ALERT_RECEIVED) {
+                       if (gnutls_is_fatal_error(ret) == 1 || ret == 0) {
+                               if (ret == 0) {
                                        printf
                                            ("\n- Peer has closed the GNUTLS connection\n");
                                        break;