Revert "Rework memory BIOs and implement BIO_seek (#2380)" (#2432)

This reverts commit 5a74835.

Our Ruby CI checks with 3.4-3.2 started failing with this commit. This
reverts the commit until we know what's up.

By submitting this pull request, I confirm that my contribution is made
under the terms of the Apache 2.0 license and the ISC license.

Author: samuel40791765

crypto/bio/bio_mem.c

@@ -65,18 +65,11 @@
 
 #include "../internal.h"
 
-typedef struct bio_buf_mem_st {
-  struct buf_mem_st *buf;   /* allocated buffer */
-  size_t read_off;          /* read pointer offset from current buffer position */
-} BIO_BUF_MEM;
-
 
 BIO *BIO_new_mem_buf(const void *buf, ossl_ssize_t len) {
   BIO *ret;
   BUF_MEM *b;
-  BIO_BUF_MEM *bbm;
-
-  const size_t size = (len < 0 || (size_t)len > SIZE_MAX) ? strlen((char *)buf) : (size_t)len;
+  const size_t size = len < 0 ? strlen((char *)buf) : (size_t)len;
 
   if (!buf && len != 0) {
     OPENSSL_PUT_ERROR(BIO, BIO_R_NULL_PARAMETER);
@@ -88,8 +81,7 @@ BIO *BIO_new_mem_buf(const void *buf, ossl_ssize_t len) {
     return NULL;
   }
 
-  bbm = (BIO_BUF_MEM *)ret->ptr;
-  b = bbm->buf;
+  b = (BUF_MEM *)ret->ptr;
   // BIO_FLAGS_MEM_RDONLY ensures |b->data| is not written to.
   b->data = (void *)buf;
   b->length = size;
@@ -106,25 +98,19 @@ BIO *BIO_new_mem_buf(const void *buf, ossl_ssize_t len) {
 }
 
 static int mem_new(BIO *bio) {
-  BIO_BUF_MEM *bbm = OPENSSL_zalloc(sizeof(*bbm));
-
-  if (bbm == NULL) {
-    return 0;
-  }
+  BUF_MEM *b;
 
-  bbm->buf = BUF_MEM_new();
-  if (bbm->buf == NULL) {
-    OPENSSL_free(bbm);
+  b = BUF_MEM_new();
+  if (b == NULL) {
     return 0;
   }
 
   // |shutdown| is used to store the close flag: whether the BIO has ownership
   // of the BUF_MEM.
-  bbm->read_off = 0;
   bio->shutdown = 1;
   bio->init = 1;
   bio->num = -1;
-  bio->ptr = (char *)bbm;
+  bio->ptr = (char *)b;
 
   return 1;
 }
@@ -134,53 +120,35 @@ static int mem_free(BIO *bio) {
     return 1;
   }
 
-  BIO_BUF_MEM *bbm = (BIO_BUF_MEM *)bio->ptr;
-  BUF_MEM *b = bbm->buf;
-
+  BUF_MEM *b = (BUF_MEM *)bio->ptr;
   if (bio->flags & BIO_FLAGS_MEM_RDONLY) {
     b->data = NULL;
   }
   BUF_MEM_free(b);
   bio->ptr = NULL;
-
-  OPENSSL_free(bbm);
   return 1;
 }
 
-static void mem_buf_sync(BIO *bio) {
-  if (bio->init != 0 && bio->ptr != NULL) {
-    BIO_BUF_MEM *bbm = (BIO_BUF_MEM *) bio->ptr;
-    BUF_MEM *b = bbm->buf;
-
-    if (b->data != NULL) {
-      if (bio->flags & BIO_FLAGS_MEM_RDONLY) {
-        b->data += bbm->read_off;
-      } else {
-        OPENSSL_memmove(b->data, &b->data[bbm->read_off], b->length);
-      }
-      bbm->read_off = 0;
-    }
-  }
-}
-
 static int mem_read(BIO *bio, char *out, int outl) {
   BIO_clear_retry_flags(bio);
   if (outl <= 0) {
     return 0;
   }
 
-  BIO_BUF_MEM *bbm = (BIO_BUF_MEM *) bio->ptr;
-  BUF_MEM *b = bbm->buf;
-
+  BUF_MEM *b = bio->ptr;
   int ret = outl;
   if ((size_t)ret > b->length) {
     ret = (int)b->length;
   }
 
   if (ret > 0) {
-    OPENSSL_memcpy(out, &b->data[bbm->read_off], ret);
+    OPENSSL_memcpy(out, b->data, ret);
     b->length -= ret;
-    bbm->read_off += ret;
+    if (bio->flags & BIO_FLAGS_MEM_RDONLY) {
+      b->data += ret;
+    } else {
+      OPENSSL_memmove(b->data, &b->data[ret], b->length);
+    }
   } else if (b->length == 0) {
     ret = bio->num;
     if (ret != 0) {
@@ -201,11 +169,7 @@ static int mem_write(BIO *bio, const char *in, int inl) {
     return -1;
   }
 
-  BIO_BUF_MEM *bbm = (BIO_BUF_MEM *) bio->ptr;
-  BUF_MEM *b = bbm->buf;
-
-  mem_buf_sync(bio);
-
+  BUF_MEM *b = bio->ptr;
   if (!BUF_MEM_append(b, in, inl)) {
     return -1;
   }
@@ -221,21 +185,16 @@ static int mem_gets(BIO *bio, char *buf, int size) {
 
   // The buffer size includes space for the trailing NUL, so we can read at most
   // one fewer byte.
-  BIO_BUF_MEM *bbm = (BIO_BUF_MEM *) bio->ptr;
-  BUF_MEM *b = bbm->buf;
+  BUF_MEM *b = bio->ptr;
   int ret = size - 1;
   if ((size_t)ret > b->length) {
     ret = (int)b->length;
   }
 
   // Stop at the first newline.
-  if (b->data != NULL) {
-    char *readp = &b->data[bbm->read_off];
-
-    const char *newline = OPENSSL_memchr(readp, '\n', ret);
-    if (newline != NULL) {
-      ret = (int)(newline - readp + 1);
-    }
+  const char *newline = OPENSSL_memchr(b->data, '\n', ret);
+  if (newline != NULL) {
+    ret = (int)(newline - b->data + 1);
   }
 
   ret = mem_read(bio, buf, ret);
@@ -248,8 +207,7 @@ static int mem_gets(BIO *bio, char *buf, int size) {
 static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
   long ret = 1;
 
-  BIO_BUF_MEM *bbm = (BIO_BUF_MEM *) bio->ptr;
-  BUF_MEM *b = bbm->buf;
+  BUF_MEM *b = (BUF_MEM *)bio->ptr;
 
   switch (cmd) {
     case BIO_CTRL_RESET:
@@ -262,31 +220,7 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
           OPENSSL_cleanse(b->data, b->max);
           b->length = 0;
         }
-        bbm->read_off = 0;
-      } else {
-        ret = -1;
-      }
-      break;
-    case BIO_C_FILE_SEEK:
-      if (b->data == NULL || num < 0 || (size_t)num > b->max) {
-        ret = -1;
-        break;
-      }
-
-      if (bio->flags & BIO_FLAGS_MEM_RDONLY) {
-        b->data -= b->max - b->length;
-        b->length = b->max - num;
-      } else {
-        if ((size_t)num > bbm->read_off + b->length) {
-          ret = -1;
-          break;
-        }
-
-        b->length = (b->length + bbm->read_off) - num;
       }
-
-      bbm->read_off = num;
-      ret = num;
       break;
     case BIO_CTRL_EOF:
       ret = (long)(b->length == 0);
@@ -298,7 +232,7 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
       ret = (long)b->length;
       if (ptr != NULL) {
         char **pptr = ptr;
-        *pptr = (b->data != NULL) ? &b->data[bbm->read_off] : NULL;
+        *pptr = b->data;
       }
       break;
     case BIO_C_SET_BUF_MEM:
@@ -308,7 +242,6 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
       break;
     case BIO_C_GET_BUF_MEM_PTR:
       if (ptr != NULL) {
-        mem_buf_sync(bio);
         BUF_MEM **pptr = ptr;
         *pptr = b;
       }
@@ -348,17 +281,14 @@ const BIO_METHOD *BIO_s_mem(void) { return &mem_method; }
 
 int BIO_mem_contents(const BIO *bio, const uint8_t **out_contents,
                      size_t *out_len) {
+  const BUF_MEM *b;
   if (!bio || bio->method != &mem_method) {
     return 0;
   }
 
-  BIO_BUF_MEM *bbm = (BIO_BUF_MEM *) bio->ptr;
-  const BUF_MEM *b = bbm->buf;
-
-  mem_buf_sync((BIO *)bio);
-
+  b = (BUF_MEM *)bio->ptr;
   if (out_contents != NULL) {
-    *out_contents = (b->data != NULL) ? (uint8_t *)&b->data[bbm->read_off] : NULL;
+    *out_contents = (uint8_t *)b->data;
   }
   if(out_len) {
     *out_len = b->length;