1 files changed, 252 insertions, 4 deletions

diff --git a/src/lib/libcrypto/bio/bss_bio.c b/src/lib/libcrypto/bio/bss_bio.c
index 562e9d8de2..0d0f9356f7 100644
--- a/src/lib/libcrypto/bio/bss_bio.c
+++ b/src/lib/libcrypto/bio/bss_bio.c
@@ -13,6 +13,7 @@
 #endif
 
 #include <assert.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -40,7 +41,8 @@ static BIO_METHOD methods_biop =
         NULL /* no bio_gets */,
         bio_ctrl,
         bio_new,
-        bio_free
+        bio_free,
+        NULL /* no bio_callback_ctrl */
 };
 
 BIO_METHOD *BIO_s_bio(void)
@@ -64,7 +66,7 @@ struct bio_bio_st
 
         size_t request; /* valid iff peer != NULL; 0 if len != 0,
                          * otherwise set by peer to number of bytes
-                         * it (unsuccesfully) tried to read,
+                         * it (unsuccessfully) tried to read,
                          * never more than buffer space (size-len) warrants. */
 };
 
@@ -195,6 +197,81 @@ static int bio_read(BIO *bio, char *buf, int size_)
         return size;
         }
 
+/* non-copying interface: provide pointer to available data in buffer
+ *    bio_nread0:  return number of available bytes
+ *    bio_nread:   also advance index
+ * (example usage:  bio_nread0(), read from buffer, bio_nread()
+ *  or just         bio_nread(), read from buffer)
+ */
+/* WARNING: The non-copying interface is largely untested as of yet
+ * and may contain bugs. */
+static size_t bio_nread0(BIO *bio, char **buf)
+        {
+        struct bio_bio_st *b, *peer_b;
+        size_t num;
+        
+        BIO_clear_retry_flags(bio);
+
+        if (!bio->init)
+                return 0;
+        
+        b = bio->ptr;
+        assert(b != NULL);
+        assert(b->peer != NULL);
+        peer_b = b->peer->ptr;
+        assert(peer_b != NULL);
+        assert(peer_b->buf != NULL);
+        
+        peer_b->request = 0;
+        
+        if (peer_b->len == 0)
+                {
+                char dummy;
+                
+                /* avoid code duplication -- nothing available for reading */
+                return bio_read(bio, &dummy, 1); /* returns 0 or -1 */
+                }
+
+        num = peer_b->len;
+        if (peer_b->size < peer_b->offset + num)
+                /* no ring buffer wrap-around for non-copying interface */
+                num = peer_b->size - peer_b->offset;
+        assert(num > 0);
+
+        if (buf != NULL)
+                *buf = peer_b->buf + peer_b->offset;
+        return num;
+        }
+
+static size_t bio_nread(BIO *bio, char **buf, size_t num)
+        {
+        struct bio_bio_st *b, *peer_b;
+        size_t available;
+
+        available = bio_nread0(bio, buf);
+        if (num > available)
+                num = available;
+        if (num == 0)
+                return num;
+
+        b = bio->ptr;
+        peer_b = b->peer->ptr;
+
+        peer_b->len -= num;
+        if (peer_b->len) 
+                {
+                peer_b->offset += num;
+                assert(peer_b->offset <= peer_b->size);
+                if (peer_b->offset == peer_b->size)
+                        peer_b->offset = 0;
+                }
+        else
+                peer_b->offset = 0;
+
+        return num;
+        }
+
+
 static int bio_write(BIO *bio, char *buf, int num_)
         {
         size_t num = num_;
@@ -268,6 +345,78 @@ static int bio_write(BIO *bio, char *buf, int num_)
         return num;
         }
 
+/* non-copying interface: provide pointer to region to write to
+ *   bio_nwrite0:  check how much space is available
+ *   bio_nwrite:   also increase length
+ * (example usage:  bio_nwrite0(), write to buffer, bio_nwrite()
+ *  or just         bio_nwrite(), write to buffer)
+ */
+static size_t bio_nwrite0(BIO *bio, char **buf)
+        {
+        struct bio_bio_st *b;
+        size_t num;
+        size_t write_offset;
+
+        BIO_clear_retry_flags(bio);
+
+        if (!bio->init)
+                return 0;
+
+        b = bio->ptr;           
+        assert(b != NULL);
+        assert(b->peer != NULL);
+        assert(b->buf != NULL);
+
+        b->request = 0;
+        if (b->closed)
+                {
+                BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE);
+                return -1;
+                }
+
+        assert(b->len <= b->size);
+
+        if (b->len == b->size)
+                {
+                BIO_set_retry_write(bio);
+                return -1;
+                }
+
+        num = b->size - b->len;
+        write_offset = b->offset + b->len;
+        if (write_offset >= b->size)
+                write_offset -= b->size;
+        if (write_offset + num > b->size)
+                /* no ring buffer wrap-around for non-copying interface
+                 * (to fulfil the promise by BIO_ctrl_get_write_guarantee,
+                 * BIO_nwrite may have to be called twice) */
+                num = b->size - write_offset;
+
+        if (buf != NULL)
+                *buf = b->buf + write_offset;
+        assert(write_offset + num <= b->size);
+
+        return num;
+        }
+
+static size_t bio_nwrite(BIO *bio, char **buf, size_t num)
+        {
+        struct bio_bio_st *b;
+        size_t space;
+
+        space = bio_nwrite0(bio, buf);
+        if (num > space)
+                num = space;
+        if (num == 0)
+                return num;
+        b = bio->ptr;
+        assert(b != NULL);
+        b->len += num;
+        assert(b->len <= b->size);
+
+        return num;
+        }
+
 
 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
         {
@@ -331,7 +480,7 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
 
         case BIO_C_GET_WRITE_GUARANTEE:
                 /* How many bytes can the caller feed to the next write
-                 * withouth having to keep any? */
+                 * without having to keep any? */
                 if (b->peer == NULL || b->closed)
                         ret = 0;
                 else
@@ -339,18 +488,42 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
                 break;
 
         case BIO_C_GET_READ_REQUEST:
-                /* If the peer unsuccesfully tried to read, how many bytes
+                /* If the peer unsuccessfully tried to read, how many bytes
                  * were requested?  (As with BIO_CTRL_PENDING, that number
                  * can usually be treated as boolean.) */
                 ret = (long) b->request;
                 break;
 
+        case BIO_C_RESET_READ_REQUEST:
+                /* Reset request.  (Can be useful after read attempts
+                 * at the other side that are meant to be non-blocking,
+                 * e.g. when probing SSL_read to see if any data is
+                 * available.) */
+                b->request = 0;
+                ret = 1;
+                break;
+
         case BIO_C_SHUTDOWN_WR:
                 /* similar to shutdown(..., SHUT_WR) */
                 b->closed = 1;
                 ret = 1;
                 break;
 
+        case BIO_C_NREAD:
+                /* non-copying read */
+                ret = (long) bio_nread(bio, ptr, (size_t) num);
+                break;
+                
+        case BIO_C_NWRITE0:
+                /* prepare for non-copying write */
+                ret = (long) bio_nwrite0(bio, ptr);
+                break;
+
+        case BIO_C_NWRITE:
+                /* non-copying write */
+                ret = (long) bio_nwrite(bio, ptr, (size_t) num);
+                break;
+                
 
         /* standard CTRL codes follow */
 
@@ -586,3 +759,78 @@ size_t BIO_ctrl_get_read_request(BIO *bio)
         {
         return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);
         }
+
+int BIO_ctrl_reset_read_request(BIO *bio)
+        {
+        return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0);
+        }
+
+
+/* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now
+ * (conceivably some other BIOs could allow non-copying reads and writes too.)
+ */
+int BIO_nread0(BIO *bio, char **buf)
+        {
+        long ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf);
+        if (ret > INT_MAX)
+                return INT_MAX;
+        else
+                return (int) ret;
+        }
+
+int BIO_nread(BIO *bio, char **buf, int num)
+        {
+        int ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf);
+        if (ret > 0)
+                bio->num_read += ret;
+        return ret;
+        }
+
+int BIO_nwrite0(BIO *bio, char **buf)
+        {
+        long ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf);
+        if (ret > INT_MAX)
+                return INT_MAX;
+        else
+                return (int) ret;
+        }
+
+int BIO_nwrite(BIO *bio, char **buf, int num)
+        {
+        int ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf);
+        if (ret > 0)
+                bio->num_read += ret;
+        return ret;
+        }