Don't return 0 from ssl2_read when a packet with empty payload is received.

[openssl.git] / ssl / s2_pkt.c

diff --git a/ssl/s2_pkt.c b/ssl/s2_pkt.c
index 96d9a1be55142a8b58070f5c41c3c5d1a51f867a..61b20305c1dff4d39b7515676571130c4c8c8f7f 100644 (file)
--- a/ssl/s2_pkt.c
+++ b/ssl/s2_pkt.c
@@ -80,10 +80,7 @@ static int write_pending();
 static int ssl_mt_error();
 #endif
 
-int ssl2_peek(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+int ssl2_peek(SSL *s, char *buf, int len)
        {
        int ret;
 
@@ -99,10 +96,7 @@ int len;
 /* SSL_read -
  * This routine will return 0 to len bytes, decrypted etc if required.
  */
-int ssl2_read(s, buf, len)
-SSL *s;
-char *buf;
-int len;
+int ssl2_read(SSL *s, char *buf, int len)
        {
        int n;
        unsigned char mac[MAX_MAC_SIZE];
@@ -110,6 +104,7 @@ int len;
        int i;
        unsigned int mac_size=0;
 
+ssl2_read_again:
        if (SSL_in_init(s) && !s->in_handshake)
                {
                n=s->handshake_func(s);
@@ -237,6 +232,25 @@ int len;
                INC32(s->s2->read_sequence); /* expect next number */
                /* s->s2->ract_data is now available for processing */
 
+#if 1
+               /* How should we react when a packet containing 0
+                * bytes is received?  (Note that SSLeay/OpenSSL itself
+                * never sends such packets; see ssl2_write.)
+                * Returning 0 would be interpreted by the caller as
+                * indicating EOF, so it's not a good idea.
+                * Instead, we just continue reading.  Note that using
+                * select() for blocking sockets *never* guarantees
+                * that the next SSL_read will not block -- the available
+                * data may contain incomplete packets, and except for SSL 2
+                * renegotiation can confuse things even more. */
+
+               goto ssl2_read_again; /* This should really be
+                                      * "return ssl2_read(s,buf,len)",
+                                      * but that would allow for
+                                      * denial-of-service attacks if a
+                                      * C compiler is used that does not
+                                      * recognize end-recursion. */
+#else
                /* If a 0 byte packet was sent, return 0, otherwise
                 * we play havoc with people using select with
                 * blocking sockets.  Let them handle a packet at a time,
@@ -244,6 +258,7 @@ int len;
                if (s->s2->ract_data_length == 0)
                        return(0);
                return(ssl2_read(s,buf,len));
+#endif
                }
        else
                {
@@ -252,11 +267,8 @@ int len;
                }
        }
 
-static int read_n(s, n, max, extend)
-SSL *s;
-unsigned int n;
-unsigned int max;
-unsigned int extend;
+static int read_n(SSL *s, unsigned int n, unsigned int max,
+            unsigned int extend)
        {
        int i,off,newb;
 
@@ -354,10 +366,7 @@ unsigned int extend;
        return(n);
        }
 
-int ssl2_write(s, buf, len)
-SSL *s;
-const char *buf;
-int len;
+int ssl2_write(SSL *s, const char *buf, int len)
        {
        unsigned int n,tot;
        int i;
@@ -403,10 +412,7 @@ int len;
                }
        }
 
-static int write_pending(s,buf,len)
-SSL *s;
-const char *buf;
-unsigned int len;
+static int write_pending(SSL *s, const char *buf, unsigned int len)
        {
        int i;
 
@@ -451,10 +457,7 @@ unsigned int len;
                }
        }
 
-static int do_ssl_write(s, buf, len)
-SSL *s;
-const char *buf;
-unsigned int len;
+static int do_ssl_write(SSL *s, const char *buf, unsigned int len)
        {
        unsigned int j,k,olen,p,mac_size,bs;
        register unsigned char *pp;
@@ -567,7 +570,7 @@ unsigned int len;
 
        /* lets try to actually write the data */
        s->s2->wpend_tot=olen;
-       s->s2->wpend_buf=(char *)buf;
+       s->s2->wpend_buf=buf;
 
        s->s2->wpend_ret=len;
 
@@ -575,10 +578,7 @@ unsigned int len;
        return(write_pending(s,buf,olen));
        }
 
-int ssl2_part_read(s,f,i)
-SSL *s;
-unsigned long f;
-int i;
+int ssl2_part_read(SSL *s, unsigned long f, int i)
        {
        unsigned char *p;
        int j;
@@ -608,8 +608,7 @@ int i;
                }
        }
 
-int ssl2_do_write(s)
-SSL *s;
+int ssl2_do_write(SSL *s)
        {
        int ret;
 
@@ -624,8 +623,7 @@ SSL *s;
        return(0);
        }
 
-static int ssl_mt_error(n)
-int n;
+static int ssl_mt_error(int n)
        {
        int ret;