grpc 1.84.1 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/bio/fd.cc

@@ -23,6 +23,8 @@
 #include <unistd.h>
 #else
 #include <io.h>
+#include <limits.h>
+#include <algorithm>
 #endif
 
 #include <openssl/err.h>
@@ -36,18 +38,18 @@
   #define BORINGSSL_CLOSE _close
   #define BORINGSSL_LSEEK _lseek
   #define BORINGSSL_READ _read
-  #define BORINGSSL_WRITE _write
 #else
   #define BORINGSSL_CLOSE close
   #define BORINGSSL_LSEEK lseek
   #define BORINGSSL_READ read
-  #define BORINGSSL_WRITE write
 #endif
 
+using namespace bssl;
+
 BIO *BIO_new_fd(int fd, int close_flag) {
   BIO *ret = BIO_new(BIO_s_fd());
-  if (ret == NULL) {
-    return NULL;
+  if (ret == nullptr) {
+    return nullptr;
   }
   BIO_set_fd(ret, fd, close_flag);
   return ret;
@@ -55,24 +57,22 @@ BIO *BIO_new_fd(int fd, int close_flag) {
 
 static int fd_new(BIO *bio) {
   // num is used to store the file descriptor.
-  bio->num = -1;
+  FromOpaque(bio)->num = -1;
   return 1;
 }
 
 static int fd_free(BIO *bio) {
-  if (bio->shutdown) {
-    if (bio->init) {
-      BORINGSSL_CLOSE(bio->num);
+  if (BIO_get_shutdown(bio)) {
+    if (BIO_get_init(bio)) {
+      BORINGSSL_CLOSE(FromOpaque(bio)->num);
     }
-    bio->init = 0;
+    BIO_set_init(bio, 0);
   }
   return 1;
 }
 
 static int fd_read(BIO *b, char *out, int outl) {
-  int ret = 0;
-
-  ret = (int)BORINGSSL_READ(b->num, out, outl);
+  int ret = (int)BORINGSSL_READ(FromOpaque(b)->num, out, outl);
   BIO_clear_retry_flags(b);
   if (ret <= 0) {
     if (bio_errno_should_retry(ret)) {
@@ -83,75 +83,68 @@ static int fd_read(BIO *b, char *out, int outl) {
   return ret;
 }
 
-static int fd_write(BIO *b, const char *in, int inl) {
-  int ret = (int)BORINGSSL_WRITE(b->num, in, inl);
+static int fd_write_ex(BIO *b, const char *in, size_t inl,
+                       size_t *out_written) {
+#if defined(OPENSSL_WINDOWS)
+  inl = std::min(inl, size_t{UINT_MAX});
+  int ret = _write(FromOpaque(b)->num, in, static_cast<unsigned>(inl));
+#else
+  ssize_t ret = write(FromOpaque(b)->num, in, inl);
+#endif
   BIO_clear_retry_flags(b);
   if (ret <= 0) {
     if (bio_errno_should_retry(ret)) {
       BIO_set_retry_write(b);
     }
+    return 0;
   }
 
-  return ret;
+  *out_written = ret;
+  return 1;
 }
 
 static long fd_ctrl(BIO *b, int cmd, long num, void *ptr) {
-  long ret = 1;
-  int *ip;
-
   switch (cmd) {
     case BIO_CTRL_RESET:
       num = 0;
       [[fallthrough]];
     case BIO_C_FILE_SEEK:
-      ret = 0;
-      if (b->init) {
-        ret = (long)BORINGSSL_LSEEK(b->num, num, SEEK_SET);
+      if (BIO_get_init(b)) {
+        return (long)BORINGSSL_LSEEK(FromOpaque(b)->num, num, SEEK_SET);
       }
-      break;
+      return 0;
     case BIO_C_FILE_TELL:
     case BIO_CTRL_INFO:
-      ret = 0;
-      if (b->init) {
-        ret = (long)BORINGSSL_LSEEK(b->num, 0, SEEK_CUR);
+      if (BIO_get_init(b)) {
+        return (long)BORINGSSL_LSEEK(FromOpaque(b)->num, 0, SEEK_CUR);
       }
-      break;
+      return 0;
     case BIO_C_SET_FD:
       fd_free(b);
-      b->num = *((int *)ptr);
-      b->shutdown = (int)num;
-      b->init = 1;
-      break;
+      FromOpaque(b)->num = *static_cast<int *>(ptr);
+      BIO_set_shutdown(b, static_cast<int>(num));
+      BIO_set_init(b, 1);
+      return 1;
     case BIO_C_GET_FD:
-      if (b->init) {
-        ip = (int *)ptr;
-        if (ip != NULL) {
-          *ip = b->num;
+      if (BIO_get_init(b)) {
+        int *out = static_cast<int *>(ptr);
+        if (out != nullptr) {
+          *out = FromOpaque(b)->num;
         }
-        return b->num;
+        return FromOpaque(b)->num;
       } else {
-        ret = -1;
+        return -1;
       }
-      break;
     case BIO_CTRL_GET_CLOSE:
-      ret = b->shutdown;
-      break;
+      return BIO_get_shutdown(b);
     case BIO_CTRL_SET_CLOSE:
-      b->shutdown = (int)num;
-      break;
-    case BIO_CTRL_PENDING:
-    case BIO_CTRL_WPENDING:
-      ret = 0;
-      break;
+      BIO_set_shutdown(b, static_cast<int>(num));
+      return 1;
     case BIO_CTRL_FLUSH:
-      ret = 1;
-      break;
+      return 1;
     default:
-      ret = 0;
-      break;
+      return 0;
   }
-
-  return ret;
 }
 
 static int fd_gets(BIO *bp, char *buf, int size) {
@@ -171,16 +164,24 @@ static int fd_gets(BIO *bp, char *buf, int size) {
 
   ptr[0] = '\0';
 
-  // The output length is bounded by |size|.
+  // The output length is bounded by `size`.
   return (int)(ptr - buf);
 }
 
 static const BIO_METHOD methods_fdp = {
-    BIO_TYPE_FD, "file descriptor", fd_write, fd_read, NULL /* puts */,
-    fd_gets,     fd_ctrl,           fd_new,   fd_free, NULL /* callback_ctrl */,
+    BIO_TYPE_FD,
+    "file descriptor",
+    /*bwrite=*/nullptr,
+    fd_write_ex,
+    fd_read,
+    fd_gets,
+    fd_ctrl,
+    fd_new,
+    fd_free,
+    /*callback_ctrl=*/nullptr,
 };
 
-const BIO_METHOD *BIO_s_fd(void) { return &methods_fdp; }
+const BIO_METHOD *BIO_s_fd() { return &methods_fdp; }
 
 #endif  // OPENSSL_NO_POSIX_IO
 

data/third_party/boringssl-with-bazel/crypto/bio/file.cc

@@ -40,6 +40,7 @@
 #include <openssl/mem.h>
 
 #include "../internal.h"
+#include "internal.h"
 
 #if defined(OPENSSL_WINDOWS)
 #include <fcntl.h>
@@ -55,7 +56,7 @@
 #else
 static FILE *fopen_if_available(const char *path, const char *mode) {
   errno = ENOENT;
-  return NULL;
+  return nullptr;
 }
 #endif
 
@@ -64,7 +65,7 @@ BIO *BIO_new_file(const char *filename, const char *mode) {
   FILE *file;
 
   file = fopen_if_available(filename, mode);
-  if (file == NULL) {
+  if (file == nullptr) {
     OPENSSL_PUT_SYSTEM_ERROR();
 
     ERR_add_error_data(5, "fopen('", filename, "','", mode, "')");
@@ -73,13 +74,13 @@ BIO *BIO_new_file(const char *filename, const char *mode) {
     } else {
       OPENSSL_PUT_ERROR(BIO, BIO_R_SYS_LIB);
     }
-    return NULL;
+    return nullptr;
   }
 
   ret = BIO_new_fp(file, BIO_CLOSE);
-  if (ret == NULL) {
+  if (ret == nullptr) {
     fclose(file);
-    return NULL;
+    return nullptr;
   }
 
   return ret;
@@ -87,8 +88,8 @@ BIO *BIO_new_file(const char *filename, const char *mode) {
 
 BIO *BIO_new_fp(FILE *stream, int flags) {
   BIO *ret = BIO_new(BIO_s_file());
-  if (ret == NULL) {
-    return NULL;
+  if (ret == nullptr) {
+    return nullptr;
   }
 
   BIO_set_fp(ret, stream, flags);
@@ -96,86 +97,80 @@ BIO *BIO_new_fp(FILE *stream, int flags) {
 }
 
 static int file_free(BIO *bio) {
-  if (!bio->shutdown) {
+  if (!BIO_get_shutdown(bio)) {
     return 1;
   }
 
-  if (bio->init && bio->ptr != NULL) {
-    fclose(reinterpret_cast<FILE *>(bio->ptr));
-    bio->ptr = NULL;
+  if (BIO_get_init(bio) && BIO_get_data(bio) != nullptr) {
+    fclose(reinterpret_cast<FILE *>(BIO_get_data(bio)));
+    BIO_set_data(bio, nullptr);
   }
-  bio->init = 0;
+  BIO_set_init(bio, 0);
 
   return 1;
 }
 
 static int file_read(BIO *b, char *out, int outl) {
-  if (!b->init) {
-    return 0;
-  }
-
-  size_t ret = fread(out, 1, outl, (FILE *)b->ptr);
-  if (ret == 0 && ferror((FILE *)b->ptr)) {
+  size_t ret = fread(out, 1, outl, (FILE *)BIO_get_data(b));
+  if (ret == 0 && ferror((FILE *)BIO_get_data(b))) {
     OPENSSL_PUT_SYSTEM_ERROR();
     OPENSSL_PUT_ERROR(BIO, ERR_R_SYS_LIB);
     return -1;
   }
 
-  // fread reads at most |outl| bytes, so |ret| fits in an int.
+  // fread reads at most `outl` bytes, so `ret` fits in an int.
   return (int)ret;
 }
 
-static int file_write(BIO *b, const char *in, int inl) {
-  if (!b->init) {
+static int file_write_ex(BIO *b, const char *in, size_t inl,
+                         size_t *out_written) {
+  if (fwrite(in, inl, 1, (FILE *)BIO_get_data(b)) == 0) {
     return 0;
   }
-
-  int ret = (int)fwrite(in, inl, 1, (FILE *)b->ptr);
-  if (ret > 0) {
-    ret = inl;
-  }
-  return ret;
+  // We currently ask |fwrite| to write one "object" of size |inl|, rather than
+  // |inl| objects of size 1. |fwrite| will only succeed if it wrote the whole
+  // input.
+  //
+  // TODO(crbug.com/518854940): This also means we discard information about
+  // partial writes.
+  *out_written = inl;
+  return 1;
 }
 
 static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
-  long ret = 1;
-  FILE *fp = (FILE *)b->ptr;
-  FILE **fpp;
-
+  FILE *fp = static_cast<FILE *>(BIO_get_data(b));
   switch (cmd) {
     case BIO_CTRL_RESET:
       num = 0;
       [[fallthrough]];
     case BIO_C_FILE_SEEK:
-      ret = (long)fseek(fp, num, 0);
-      break;
+      return fseek(fp, num, 0);
     case BIO_CTRL_EOF:
-      ret = (long)feof(fp);
-      break;
+      // feof may return any non-zero value for EOF, but we must return 1.
+      return feof(fp) != 0;
     case BIO_C_FILE_TELL:
     case BIO_CTRL_INFO:
-      ret = ftell(fp);
-      break;
+      return ftell(fp);
     case BIO_C_SET_FILE_PTR:
       file_free(b);
       static_assert((BIO_CLOSE & BIO_FP_TEXT) == 0,
                     "BIO_CLOSE and BIO_FP_TEXT must not collide");
 #if defined(OPENSSL_WINDOWS)
-      // If |BIO_FP_TEXT| is not set, OpenSSL will switch the file to binary
+      // If `BIO_FP_TEXT` is not set, OpenSSL will switch the file to binary
       // mode. BoringSSL intentionally diverges here because it means code
-      // tested under POSIX will inadvertently change the state of |FILE|
-      // objects when wrapping them in a |BIO|.
+      // tested under POSIX will inadvertently change the state of `FILE`
+      // objects when wrapping them in a `BIO`.
       if (num & BIO_FP_TEXT) {
         _setmode(_fileno(reinterpret_cast<FILE *>(ptr)), _O_TEXT);
       }
 #endif
-      b->shutdown = (int)num & BIO_CLOSE;
-      b->ptr = ptr;
-      b->init = 1;
-      break;
+      BIO_set_shutdown(b, static_cast<int>(num) & BIO_CLOSE);
+      BIO_set_data(b, ptr);
+      BIO_set_init(b, 1);
+      return 1;
     case BIO_C_SET_FILENAME:
       file_free(b);
-      b->shutdown = (int)num & BIO_CLOSE;
+      BIO_set_shutdown(b, static_cast<int>(num) & BIO_CLOSE);
       const char *mode;
       if (num & BIO_FP_APPEND) {
         if (num & BIO_FP_READ) {
@@ -191,43 +186,35 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
         mode = "rb";
       } else {
         OPENSSL_PUT_ERROR(BIO, BIO_R_BAD_FOPEN_MODE);
-        ret = 0;
-        break;
+        return 0;
       }
       fp = fopen_if_available(reinterpret_cast<const char *>(ptr), mode);
-      if (fp == NULL) {
+      if (fp == nullptr) {
         OPENSSL_PUT_SYSTEM_ERROR();
         ERR_add_error_data(5, "fopen('", ptr, "','", mode, "')");
         OPENSSL_PUT_ERROR(BIO, ERR_R_SYS_LIB);
-        ret = 0;
-        break;
+        return 0;
       }
-      b->ptr = fp;
-      b->init = 1;
-      break;
+      BIO_set_data(b, fp);
+      BIO_set_init(b, 1);
+      return 1;
     case BIO_C_GET_FILE_PTR:
       // the ptr parameter is actually a FILE ** in this case.
-      if (ptr != NULL) {
-        fpp = (FILE **)ptr;
-        *fpp = (FILE *)b->ptr;
+      if (ptr != nullptr) {
+        FILE **out = static_cast<FILE **>(ptr);
+        *out = fp;
       }
-      break;
+      return 1;
     case BIO_CTRL_GET_CLOSE:
-      ret = (long)b->shutdown;
-      break;
+      return BIO_get_shutdown(b);
     case BIO_CTRL_SET_CLOSE:
-      b->shutdown = (int)num;
-      break;
+      BIO_set_shutdown(b, static_cast<int>(num));
+      return 1;
     case BIO_CTRL_FLUSH:
-      ret = 0 == fflush((FILE *)b->ptr);
-      break;
-    case BIO_CTRL_WPENDING:
-    case BIO_CTRL_PENDING:
+      return fflush(fp) == 0;
     default:
-      ret = 0;
-      break;
+      return 0;
   }
-  return ret;
 }
 
 static int file_gets(BIO *bp, char *buf, int size) {
@@ -235,10 +222,10 @@ static int file_gets(BIO *bp, char *buf, int size) {
     return 0;
   }
 
-  if (!fgets(buf, size, (FILE *)bp->ptr)) {
+  if (!fgets(buf, size, (FILE *)BIO_get_data(bp))) {
     buf[0] = 0;
     // TODO(davidben): This doesn't distinguish error and EOF. This should check
-    // |ferror| as in |file_read|.
+    // `ferror` as in `file_read`.
     return 0;
   }
 
@@ -246,14 +233,19 @@ static int file_gets(BIO *bp, char *buf, int size) {
 }
 
 static const BIO_METHOD methods_filep = {
-    BIO_TYPE_FILE,   "FILE pointer",
-    file_write,      file_read,
-    NULL /* puts */, file_gets,
-    file_ctrl,       NULL /* create */,
-    file_free,       NULL /* callback_ctrl */,
+    BIO_TYPE_FILE,
+    "FILE pointer",
+    /*bwrite=*/nullptr,
+    file_write_ex,
+    file_read,
+    file_gets,
+    file_ctrl,
+    /*create=*/nullptr,
+    file_free,
+    /*callback_ctrl=*/nullptr,
 };
 
-const BIO_METHOD *BIO_s_file(void) { return &methods_filep; }
+const BIO_METHOD *BIO_s_file() { return &methods_filep; }
 
 
 int BIO_get_fp(BIO *bio, FILE **out_file) {
@@ -285,8 +277,8 @@ int BIO_rw_filename(BIO *bio, const char *filename) {
                        (char *)filename);
 }
 
-long BIO_tell(BIO *bio) { return BIO_ctrl(bio, BIO_C_FILE_TELL, 0, NULL); }
+long BIO_tell(BIO *bio) { return BIO_ctrl(bio, BIO_C_FILE_TELL, 0, nullptr); }
 
 long BIO_seek(BIO *bio, long offset) {
-  return BIO_ctrl(bio, BIO_C_FILE_SEEK, offset, NULL);
+  return BIO_ctrl(bio, BIO_C_FILE_SEEK, offset, nullptr);
 }

data/third_party/boringssl-with-bazel/crypto/bio/hexdump.cc

@@ -20,6 +20,8 @@
 #include "../internal.h"
 
 
+using namespace bssl;
+
 namespace {
 // hexdump_ctx contains the state of a hexdump.
 struct hexdump_ctx {
@@ -44,8 +46,8 @@ static char to_char(uint8_t b) {
   return b;
 }
 
-// hexdump_write adds |len| bytes of |data| to the current hex dump described by
-// |ctx|.
+// hexdump_write adds `len` bytes of `data` to the current hex dump described by
+// `ctx`.
 static int hexdump_write(struct hexdump_ctx *ctx, const uint8_t *data,
                          size_t len) {
   char buf[10];
@@ -104,9 +106,9 @@ static int hexdump_write(struct hexdump_ctx *ctx, const uint8_t *data,
   return 1;
 }
 
-// finish flushes any buffered data in |ctx|.
+// finish flushes any buffered data in `ctx`.
 static int finish(struct hexdump_ctx *ctx) {
-  // See the comments in |hexdump| for the details of this format.
+  // See the comments in `hexdump` for the details of this format.
   const unsigned n_bytes = ctx->used;
   unsigned l;
   char buf[5];

data/third_party/boringssl-with-bazel/crypto/bio/internal.h

@@ -15,7 +15,12 @@
 #ifndef OPENSSL_HEADER_CRYPTO_BIO_INTERNAL_H
 #define OPENSSL_HEADER_CRYPTO_BIO_INTERNAL_H
 
-#include <openssl/base.h>
+#include <openssl/bio.h>
+
+#include <openssl/ex_data.h>
+
+#include "../internal.h"
+#include "../mem_internal.h"
 
 #if !defined(OPENSSL_NO_SOCK)
 #if !defined(OPENSSL_WINDOWS)
@@ -31,47 +36,94 @@ typedef int socklen_t;
 #endif
 #endif  // !OPENSSL_NO_SOCK
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
 
+DECLARE_OPAQUE_STRUCT(bio_st, Bio)
+
+struct bio_method_st {
+  int type;
+  const char *name;
+  int (*bwrite)(BIO *, const char *, int);
+  int (*bwrite_ex)(BIO *, const char *, size_t, size_t *);
+  int (*bread)(BIO *, char *, int);
+  int (*bgets)(BIO *, char *, int);
+  long (*ctrl)(BIO *, int, long, void *);
+  int (*create)(BIO *);
+  int (*destroy)(BIO *);
+  long (*callback_ctrl)(BIO *, int, BIO_info_cb *);
+};
+
+BSSL_NAMESPACE_BEGIN
+
+class Bio : public bio_st, public RefCounted<Bio> {
+ public:
+  explicit Bio(const BIO_METHOD *m);
+
+  const BIO_METHOD *method;
+  CRYPTO_EX_DATA ex_data;
+
+  // TODO(crbug.com/412269080): `init` and `shutdown` could be bitfields, or
+  // integrated into `flags`, to save memory.
+
+  // init is non-zero if this `BIO` has been initialised.
+  int init = 0;
+  // shutdown is often used by specific `BIO_METHOD`s to determine whether
+  // they own some underlying resource. This flag can often be controlled by
+  // `BIO_set_close`. For example, whether an fd BIO closes the underlying fd
+  // when it, itself, is closed.
+  int shutdown = 1;
+  int flags = 0;
+  int retry_reason = 0;
+  // num is a BIO-specific value. For example, in fd BIOs it's used to store a
+  // file descriptor.
+  int num = 0;
+  void *ptr = nullptr;
+  // next_bio points to the next `BIO` in a chain. This `BIO` owns a reference
+  // to `next_bio`.
+  Bio *next_bio = nullptr;  // used by filter BIOs
+  uint64_t num_read = 0, num_write = 0;
+
+ private:
+  friend RefCounted;
+  ~Bio();
+};
 
 #if !defined(OPENSSL_NO_SOCK)
 
-// bio_ip_and_port_to_socket_and_addr creates a socket and fills in |*out_addr|
-// and |*out_addr_length| with the correct values for connecting to |hostname|
-// on |port_str|. It returns one on success or zero on error.
+// bio_ip_and_port_to_socket_and_addr creates a socket and fills in `*out_addr`
+// and `*out_addr_length` with the correct values for connecting to `hostname`
+// on `port_str`. It returns one on success or zero on error.
 int bio_ip_and_port_to_socket_and_addr(int *out_sock,
                                        struct sockaddr_storage *out_addr,
                                        socklen_t *out_addr_length,
                                        const char *hostname,
                                        const char *port_str);
 
-// bio_socket_nbio sets whether |sock| is non-blocking. It returns one on
+// bio_socket_nbio sets whether `sock` is non-blocking. It returns one on
 // success and zero otherwise.
 int bio_socket_nbio(int sock, int on);
 
 // bio_clear_socket_error clears the last system socket error.
 //
 // TODO(fork): remove all callers of this.
-void bio_clear_socket_error(void);
+void bio_clear_socket_error();
 
-// bio_sock_error returns the last socket error on |sock|.
-int bio_sock_error(int sock);
+// bio_socket_finish_connect attempts to complete an in-progress, non-blocking
+// connect operation on `sock`. It returns one if the connect operation
+// suceeded. Otherwise, it returns zero and sets the last socket error to the
+// reason it failed.
+int bio_socket_finish_connect(int sock);
 
-// bio_socket_should_retry returns non-zero if |return_value| indicates an error
+// bio_socket_should_retry returns non-zero if `return_value` indicates an error
 // and the last socket error indicates that it's non-fatal.
 int bio_socket_should_retry(int return_value);
 
 #endif  // !OPENSSL_NO_SOCK
 
-// bio_errno_should_retry returns non-zero if |return_value| indicates an error
-// and |errno| indicates that it's non-fatal.
+// bio_errno_should_retry returns non-zero if `return_value` indicates an error
+// and `errno` indicates that it's non-fatal.
 int bio_errno_should_retry(int return_value);
 
+BSSL_NAMESPACE_END
 
-#if defined(__cplusplus)
-}  // extern C
-#endif
 
 #endif  // OPENSSL_HEADER_CRYPTO_BIO_INTERNAL_H