grpc 1.53.0 → 1.55.0

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_utl.c

@@ -60,27 +60,28 @@
 #include <string.h>
 
 #include <openssl/asn1t.h>
+#include <openssl/err.h>
 #include <openssl/mem.h>
 #include <openssl/obj.h>
-#include <openssl/err.h>
+#include <openssl/pool.h>
 #include <openssl/thread.h>
 
 #include "../internal.h"
 #include "internal.h"
 
 
-/* Utility functions for manipulating fields and offsets */
+// Utility functions for manipulating fields and offsets
 
-/* Add 'offset' to 'addr' */
+// Add 'offset' to 'addr'
 #define offset2ptr(addr, offset) (void *)(((char *)(addr)) + (offset))
 
-/* Given an ASN1_ITEM CHOICE type return the selector value */
+// Given an ASN1_ITEM CHOICE type return the selector value
 int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   int *sel = offset2ptr(*pval, it->utype);
   return *sel;
 }
 
-/* Given an ASN1_ITEM CHOICE type set the selector value, return old value. */
+// Given an ASN1_ITEM CHOICE type set the selector value, return old value.
 int asn1_set_choice_selector(ASN1_VALUE **pval, int value,
                              const ASN1_ITEM *it) {
   int *sel, ret;
@@ -131,68 +132,62 @@ static ASN1_ENCODING *asn1_get_enc_ptr(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 }
 
 void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it) {
-  ASN1_ENCODING *enc;
-  enc = asn1_get_enc_ptr(pval, it);
+  ASN1_ENCODING *enc = asn1_get_enc_ptr(pval, it);
   if (enc) {
     enc->enc = NULL;
     enc->len = 0;
-    enc->alias_only = 0;
-    enc->alias_only_on_next_parse = 0;
-    enc->modified = 1;
+    enc->buf = NULL;
   }
 }
 
 void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
-  ASN1_ENCODING *enc;
-  enc = asn1_get_enc_ptr(pval, it);
+  ASN1_ENCODING *enc = asn1_get_enc_ptr(pval, it);
   if (enc) {
-    if (enc->enc && !enc->alias_only) {
-      OPENSSL_free(enc->enc);
-    }
-    enc->enc = NULL;
-    enc->len = 0;
-    enc->alias_only = 0;
-    enc->alias_only_on_next_parse = 0;
-    enc->modified = 1;
+    asn1_encoding_clear(enc);
   }
 }
 
-int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
-                  const ASN1_ITEM *it) {
+int asn1_enc_save(ASN1_VALUE **pval, const uint8_t *in, size_t in_len,
+                  const ASN1_ITEM *it, CRYPTO_BUFFER *buf) {
   ASN1_ENCODING *enc;
   enc = asn1_get_enc_ptr(pval, it);
   if (!enc) {
     return 1;
   }
 
-  if (!enc->alias_only) {
-    OPENSSL_free(enc->enc);
-  }
-
-  enc->alias_only = enc->alias_only_on_next_parse;
-  enc->alias_only_on_next_parse = 0;
-
-  if (enc->alias_only) {
-    enc->enc = (uint8_t *) in;
+  asn1_encoding_clear(enc);
+  if (buf != NULL) {
+    assert(CRYPTO_BUFFER_data(buf) <= in &&
+           in + in_len <= CRYPTO_BUFFER_data(buf) + CRYPTO_BUFFER_len(buf));
+    CRYPTO_BUFFER_up_ref(buf);
+    enc->buf = buf;
+    enc->enc = (uint8_t *)in;
   } else {
-    enc->enc = OPENSSL_malloc(inlen);
+    enc->enc = OPENSSL_memdup(in, in_len);
     if (!enc->enc) {
       return 0;
     }
-    OPENSSL_memcpy(enc->enc, in, inlen);
   }
 
-  enc->len = inlen;
-  enc->modified = 0;
-
+  enc->len = in_len;
   return 1;
 }
 
+void asn1_encoding_clear(ASN1_ENCODING *enc) {
+  if (enc->buf != NULL) {
+    CRYPTO_BUFFER_free(enc->buf);
+  } else {
+    OPENSSL_free(enc->enc);
+  }
+  enc->enc = NULL;
+  enc->len = 0;
+  enc->buf = NULL;
+}
+
 int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
                      const ASN1_ITEM *it) {
-  ASN1_ENCODING *enc;
-  enc = asn1_get_enc_ptr(pval, it);
-  if (!enc || enc->modified) {
+  ASN1_ENCODING *enc = asn1_get_enc_ptr(pval, it);
+  if (!enc || enc->len == 0) {
     return 0;
   }
   if (out) {
@@ -205,38 +200,33 @@ int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
   return 1;
 }
 
-/* Given an ASN1_TEMPLATE get a pointer to a field */
+// Given an ASN1_TEMPLATE get a pointer to a field
 ASN1_VALUE **asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
-  ASN1_VALUE **pvaltmp;
-  if (tt->flags & ASN1_TFLG_COMBINE) {
-    return pval;
-  }
-  pvaltmp = offset2ptr(*pval, tt->offset);
-  /* NOTE for BOOLEAN types the field is just a plain int so we can't return
-   * int **, so settle for (int *). */
+  ASN1_VALUE **pvaltmp = offset2ptr(*pval, tt->offset);
+  // NOTE for BOOLEAN types the field is just a plain int so we can't return
+  // int **, so settle for (int *).
   return pvaltmp;
 }
 
-/* Handle ANY DEFINED BY template, find the selector, look up the relevant
- * ASN1_TEMPLATE in the table and return it. */
+// Handle ANY DEFINED BY template, find the selector, look up the relevant
+// ASN1_TEMPLATE in the table and return it.
 const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
                                  int nullerr) {
   const ASN1_ADB *adb;
   const ASN1_ADB_TABLE *atbl;
-  long selector;
   ASN1_VALUE **sfld;
   int i;
   if (!(tt->flags & ASN1_TFLG_ADB_MASK)) {
     return tt;
   }
 
-  /* Else ANY DEFINED BY ... get the table */
+  // Else ANY DEFINED BY ... get the table
   adb = ASN1_ADB_ptr(tt->item);
 
-  /* Get the selector field */
+  // Get the selector field
   sfld = offset2ptr(*pval, adb->offset);
 
-  /* Check if NULL */
+  // Check if NULL
   if (*sfld == NULL) {
     if (!adb->null_tt) {
       goto err;
@@ -244,19 +234,16 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
     return adb->null_tt;
   }
 
-  /* Convert type to a long:
-   * NB: don't check for NID_undef here because it
-   * might be a legitimate value in the table */
-  if (tt->flags & ASN1_TFLG_ADB_OID) {
-    selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld);
-  } else {
-    selector = ASN1_INTEGER_get((ASN1_INTEGER *)*sfld);
-  }
+  // Convert type to a NID:
+  // NB: don't check for NID_undef here because it
+  // might be a legitimate value in the table
+  assert(tt->flags & ASN1_TFLG_ADB_OID);
+  int selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld);
 
-  /* Try to find matching entry in table Maybe should check application types
-   * first to allow application override? Might also be useful to have a flag
-   * which indicates table is sorted and we can do a binary search. For now
-   * stick to a linear search. */
+  // Try to find matching entry in table Maybe should check application types
+  // first to allow application override? Might also be useful to have a flag
+  // which indicates table is sorted and we can do a binary search. For now
+  // stick to a linear search.
 
   for (atbl = adb->tbl, i = 0; i < adb->tblcount; i++, atbl++) {
     if (atbl->value == selector) {
@@ -264,16 +251,16 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
     }
   }
 
-  /* FIXME: need to search application table too */
+  // FIXME: need to search application table too
 
-  /* No match, return default type */
+  // No match, return default type
   if (!adb->default_tt) {
     goto err;
   }
   return adb->default_tt;
 
 err:
-  /* FIXME: should log the value or OID of unsupported type */
+  // FIXME: should log the value or OID of unsupported type
   if (nullerr) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE);
   }

data/third_party/boringssl-with-bazel/src/crypto/base64/base64.c

@@ -60,8 +60,6 @@
 #include <limits.h>
 #include <string.h>
 
-#include <openssl/type_check.h>
-
 #include "../internal.h"
 
 
@@ -98,8 +96,8 @@ static uint8_t conv_bin2ascii(uint8_t a) {
   return ret;
 }
 
-OPENSSL_STATIC_ASSERT(sizeof(((EVP_ENCODE_CTX *)(NULL))->data) % 3 == 0,
-                      "data length must be a multiple of base64 chunk size");
+static_assert(sizeof(((EVP_ENCODE_CTX *)(NULL))->data) % 3 == 0,
+              "data length must be a multiple of base64 chunk size");
 
 int EVP_EncodedLength(size_t *out_len, size_t len) {
   if (len + 2 < len) {

data/third_party/boringssl-with-bazel/src/crypto/bio/bio.c

@@ -72,7 +72,6 @@
 BIO *BIO_new(const BIO_METHOD *method) {
   BIO *ret = OPENSSL_malloc(sizeof(BIO));
   if (ret == NULL) {
-    OPENSSL_PUT_ERROR(BIO, ERR_R_MALLOC_FAILURE);
     return NULL;
   }
 
@@ -192,11 +191,17 @@ int BIO_write_all(BIO *bio, const void *data, size_t len) {
 }
 
 int BIO_puts(BIO *bio, const char *in) {
-  return BIO_write(bio, in, strlen(in));
+  size_t len = strlen(in);
+  if (len > INT_MAX) {
+    // |BIO_write| and the return value both assume the string fits in |int|.
+    OPENSSL_PUT_ERROR(BIO, ERR_R_OVERFLOW);
+    return -1;
+  }
+  return BIO_write(bio, in, (int)len);
 }
 
 int BIO_flush(BIO *bio) {
-  return BIO_ctrl(bio, BIO_CTRL_FLUSH, 0, NULL);
+  return (int)BIO_ctrl(bio, BIO_CTRL_FLUSH, 0, NULL);
 }
 
 long BIO_ctrl(BIO *bio, int cmd, long larg, void *parg) {
@@ -229,11 +234,11 @@ long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) {
 }
 
 int BIO_reset(BIO *bio) {
-  return BIO_ctrl(bio, BIO_CTRL_RESET, 0, NULL);
+  return (int)BIO_ctrl(bio, BIO_CTRL_RESET, 0, NULL);
 }
 
 int BIO_eof(BIO *bio) {
-  return BIO_ctrl(bio, BIO_CTRL_EOF, 0, NULL);
+  return (int)BIO_ctrl(bio, BIO_CTRL_EOF, 0, NULL);
 }
 
 void BIO_set_flags(BIO *bio, int flags) {
@@ -333,7 +338,7 @@ size_t BIO_wpending(const BIO *bio) {
 }
 
 int BIO_set_close(BIO *bio, int close_flag) {
-  return BIO_ctrl(bio, BIO_CTRL_SET_CLOSE, close_flag, NULL);
+  return (int)BIO_ctrl(bio, BIO_CTRL_SET_CLOSE, close_flag, NULL);
 }
 
 OPENSSL_EXPORT size_t BIO_number_read(const BIO *bio) {
@@ -603,7 +608,6 @@ int BIO_read_asn1(BIO *bio, uint8_t **out, size_t *out_len, size_t max_len) {
 
   *out = OPENSSL_malloc(len);
   if (*out == NULL) {
-    OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
     return 0;
   }
   OPENSSL_memcpy(*out, header, header_len);

data/third_party/boringssl-with-bazel/src/crypto/bio/bio_mem.c

@@ -66,7 +66,7 @@
 #include "../internal.h"
 
 
-BIO *BIO_new_mem_buf(const void *buf, int len) {
+BIO *BIO_new_mem_buf(const void *buf, ossl_ssize_t len) {
   BIO *ret;
   BUF_MEM *b;
   const size_t size = len < 0 ? strlen((char *)buf) : (size_t)len;
@@ -130,13 +130,15 @@ static int mem_free(BIO *bio) {
 }
 
 static int mem_read(BIO *bio, char *out, int outl) {
-  int ret;
-  BUF_MEM *b = (BUF_MEM*) bio->ptr;
-
   BIO_clear_retry_flags(bio);
-  ret = outl;
-  if (b->length < INT_MAX && ret > (int)b->length) {
-    ret = b->length;
+  if (outl <= 0) {
+    return 0;
+  }
+
+  BUF_MEM *b = bio->ptr;
+  int ret = outl;
+  if ((size_t)ret > b->length) {
+    ret = (int)b->length;
   }
 
   if (ret > 0) {
@@ -157,65 +159,49 @@ static int mem_read(BIO *bio, char *out, int outl) {
 }
 
 static int mem_write(BIO *bio, const char *in, int inl) {
-  int ret = -1;
-  int blen;
-  BUF_MEM *b;
-
-  b = (BUF_MEM *)bio->ptr;
+  BIO_clear_retry_flags(bio);
+  if (inl <= 0) {
+    return 0;  // Successfully write zero bytes.
+  }
 
   if (bio->flags & BIO_FLAGS_MEM_RDONLY) {
     OPENSSL_PUT_ERROR(BIO, BIO_R_WRITE_TO_READ_ONLY_BIO);
-    goto err;
+    return -1;
   }
 
-  BIO_clear_retry_flags(bio);
-  blen = b->length;
-  if (INT_MAX - blen < inl) {
-    goto err;
+  BUF_MEM *b = bio->ptr;
+  if (!BUF_MEM_append(b, in, inl)) {
+    return -1;
   }
-  if (BUF_MEM_grow_clean(b, blen + inl) != ((size_t) blen) + inl) {
-    goto err;
-  }
-  OPENSSL_memcpy(&b->data[blen], in, inl);
-  ret = inl;
 
-err:
-  return ret;
+  return inl;
 }
 
 static int mem_gets(BIO *bio, char *buf, int size) {
-  int i, j;
-  char *p;
-  BUF_MEM *b = (BUF_MEM *)bio->ptr;
-
   BIO_clear_retry_flags(bio);
-  j = b->length;
-  if (size - 1 < j) {
-    j = size - 1;
-  }
-  if (j <= 0) {
-    if (size > 0) {
-      *buf = 0;
-    }
+  if (size <= 0) {
     return 0;
   }
 
-  p = b->data;
-  for (i = 0; i < j; i++) {
-    if (p[i] == '\n') {
-      i++;
-      break;
-    }
+  // The buffer size includes space for the trailing NUL, so we can read at most
+  // one fewer byte.
+  BUF_MEM *b = bio->ptr;
+  int ret = size - 1;
+  if ((size_t)ret > b->length) {
+    ret = (int)b->length;
   }
 
-  // i is now the max num of bytes to copy, either j or up to and including the
-  // first newline
+  // Stop at the first newline.
+  const char *newline = OPENSSL_memchr(b->data, '\n', ret);
+  if (newline != NULL) {
+    ret = (int)(newline - b->data + 1);
+  }
 
-  i = mem_read(bio, buf, i);
-  if (i > 0) {
-    buf[i] = '\0';
+  ret = mem_read(bio, buf, ret);
+  if (ret >= 0) {
+    buf[ret] = '\0';
   }
-  return i;
+  return ret;
 }
 
 static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
@@ -312,13 +298,13 @@ long BIO_get_mem_data(BIO *bio, char **contents) {
 }
 
 int BIO_get_mem_ptr(BIO *bio, BUF_MEM **out) {
-  return BIO_ctrl(bio, BIO_C_GET_BUF_MEM_PTR, 0, (char *) out);
+  return (int)BIO_ctrl(bio, BIO_C_GET_BUF_MEM_PTR, 0, (char *) out);
 }
 
 int BIO_set_mem_buf(BIO *bio, BUF_MEM *b, int take_ownership) {
-  return BIO_ctrl(bio, BIO_C_SET_BUF_MEM, take_ownership, (char *) b);
+  return (int)BIO_ctrl(bio, BIO_C_SET_BUF_MEM, take_ownership, (char *) b);
 }
 
 int BIO_set_mem_eof_return(BIO *bio, int eof_value) {
-  return BIO_ctrl(bio, BIO_C_SET_BUF_MEM_EOF_RETURN, eof_value, NULL);
+  return (int)BIO_ctrl(bio, BIO_C_SET_BUF_MEM_EOF_RETURN, eof_value, NULL);
 }

data/third_party/boringssl-with-bazel/src/crypto/bio/connect.c

@@ -117,7 +117,8 @@ static int closesocket(int sock) {
 // split_host_and_port sets |*out_host| and |*out_port| to the host and port
 // parsed from |name|. It returns one on success or zero on error. Even when
 // successful, |*out_port| may be NULL on return if no port was specified.
-static int split_host_and_port(char **out_host, char **out_port, const char *name) {
+static int split_host_and_port(char **out_host, char **out_port,
+                               const char *name) {
   const char *host, *port = NULL;
   size_t host_len = 0;
 
@@ -362,7 +363,7 @@ static int conn_read(BIO *bio, char *out, int out_len) {
   }
 
   bio_clear_socket_error();
-  ret = recv(bio->num, out, out_len, 0);
+  ret = (int)recv(bio->num, out, out_len, 0);
   BIO_clear_retry_flags(bio);
   if (ret <= 0) {
     if (bio_fd_should_retry(ret)) {
@@ -386,7 +387,7 @@ static int conn_write(BIO *bio, const char *in, int in_len) {
   }
 
   bio_clear_socket_error();
-  ret = send(bio->num, in, in_len, 0);
+  ret = (int)send(bio->num, in, in_len, 0);
   BIO_clear_retry_flags(bio);
   if (ret <= 0) {
     if (bio_fd_should_retry(ret)) {
@@ -466,8 +467,7 @@ static long conn_ctrl(BIO *bio, int cmd, long num, void *ptr) {
     case BIO_CTRL_FLUSH:
       break;
     case BIO_CTRL_GET_CALLBACK: {
-      int (**fptr)(const BIO *bio, int state, int xret);
-      fptr = (int (**)(const BIO *bio, int state, int xret))ptr;
+      int (**fptr)(const BIO *bio, int state, int xret) = ptr;
       *fptr = data->info_callback;
     } break;
     default:
@@ -485,7 +485,13 @@ static long conn_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
 
   switch (cmd) {
     case BIO_CTRL_SET_CALLBACK:
+      // This is the actual type signature of |fp|. The caller is expected to
+      // cast it to |bio_info_cb| due to the |BIO_callback_ctrl| calling
+      // convention.
+      OPENSSL_MSVC_PRAGMA(warning(push))
+      OPENSSL_MSVC_PRAGMA(warning(disable : 4191))
       data->info_callback = (int (*)(const struct bio_st *, int, int))fp;
+      OPENSSL_MSVC_PRAGMA(warning(pop))
       break;
     default:
       ret = 0;
@@ -517,11 +523,11 @@ static const BIO_METHOD methods_connectp = {
 const BIO_METHOD *BIO_s_connect(void) { return &methods_connectp; }
 
 int BIO_set_conn_hostname(BIO *bio, const char *name) {
-  return BIO_ctrl(bio, BIO_C_SET_CONNECT, 0, (void*) name);
+  return (int)BIO_ctrl(bio, BIO_C_SET_CONNECT, 0, (void*) name);
 }
 
 int BIO_set_conn_port(BIO *bio, const char *port_str) {
-  return BIO_ctrl(bio, BIO_C_SET_CONNECT, 1, (void*) port_str);
+  return (int)BIO_ctrl(bio, BIO_C_SET_CONNECT, 1, (void*) port_str);
 }
 
 int BIO_set_conn_int_port(BIO *bio, const int *port) {
@@ -531,11 +537,11 @@ int BIO_set_conn_int_port(BIO *bio, const int *port) {
 }
 
 int BIO_set_nbio(BIO *bio, int on) {
-  return BIO_ctrl(bio, BIO_C_SET_NBIO, on, NULL);
+  return (int)BIO_ctrl(bio, BIO_C_SET_NBIO, on, NULL);
 }
 
 int BIO_do_connect(BIO *bio) {
-  return BIO_ctrl(bio, BIO_C_DO_STATE_MACHINE, 0, NULL);
+  return (int)BIO_ctrl(bio, BIO_C_DO_STATE_MACHINE, 0, NULL);
 }
 
 #endif  // OPENSSL_TRUSTY

data/third_party/boringssl-with-bazel/src/crypto/bio/fd.c

@@ -158,7 +158,7 @@ static int fd_free(BIO *bio) {
 static int fd_read(BIO *b, char *out, int outl) {
   int ret = 0;
 
-  ret = BORINGSSL_READ(b->num, out, outl);
+  ret = (int)BORINGSSL_READ(b->num, out, outl);
   BIO_clear_retry_flags(b);
   if (ret <= 0) {
     if (bio_fd_should_retry(ret)) {
@@ -170,7 +170,7 @@ static int fd_read(BIO *b, char *out, int outl) {
 }
 
 static int fd_write(BIO *b, const char *in, int inl) {
-  int ret = BORINGSSL_WRITE(b->num, in, inl);
+  int ret = (int)BORINGSSL_WRITE(b->num, in, inl);
   BIO_clear_retry_flags(b);
   if (ret <= 0) {
     if (bio_fd_should_retry(ret)) {
@@ -241,15 +241,18 @@ static long fd_ctrl(BIO *b, int cmd, long num, void *ptr) {
 }
 
 static int fd_gets(BIO *bp, char *buf, int size) {
-  char *ptr = buf;
-  char *end = buf + size - 1;
-
   if (size <= 0) {
     return 0;
   }
 
-  while (ptr < end && fd_read(bp, ptr, 1) > 0 && ptr[0] != '\n') {
+  char *ptr = buf;
+  char *end = buf + size - 1;
+  while (ptr < end && fd_read(bp, ptr, 1) > 0) {
+    char c = ptr[0];
     ptr++;
+    if (c == '\n') {
+      break;
+    }
   }
 
   ptr[0] = '\0';
@@ -265,11 +268,11 @@ static const BIO_METHOD methods_fdp = {
 const BIO_METHOD *BIO_s_fd(void) { return &methods_fdp; }
 
 int BIO_set_fd(BIO *bio, int fd, int close_flag) {
-  return BIO_int_ctrl(bio, BIO_C_SET_FD, close_flag, fd);
+  return (int)BIO_int_ctrl(bio, BIO_C_SET_FD, close_flag, fd);
 }
 
 int BIO_get_fd(BIO *bio, int *out_fd) {
-  return BIO_ctrl(bio, BIO_C_GET_FD, 0, (char *) out_fd);
+  return (int)BIO_ctrl(bio, BIO_C_GET_FD, 0, (char *) out_fd);
 }
 
 #endif  // OPENSSL_TRUSTY

data/third_party/boringssl-with-bazel/src/crypto/bio/file.c

@@ -281,31 +281,38 @@ const BIO_METHOD *BIO_s_file(void) { return &methods_filep; }
 
 
 int BIO_get_fp(BIO *bio, FILE **out_file) {
-  return BIO_ctrl(bio, BIO_C_GET_FILE_PTR, 0, (char*) out_file);
+  return (int)BIO_ctrl(bio, BIO_C_GET_FILE_PTR, 0, (char *)out_file);
 }
 
 int BIO_set_fp(BIO *bio, FILE *file, int close_flag) {
-  return BIO_ctrl(bio, BIO_C_SET_FILE_PTR, close_flag, (char *) file);
+  return (int)BIO_ctrl(bio, BIO_C_SET_FILE_PTR, close_flag, (char *)file);
 }
 
 int BIO_read_filename(BIO *bio, const char *filename) {
-  return BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_READ,
-                  (char *)filename);
+  return (int)BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_READ,
+                       (char *)filename);
 }
 
 int BIO_write_filename(BIO *bio, const char *filename) {
-  return BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_WRITE,
-                  (char *)filename);
+  return (int)BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_WRITE,
+                       (char *)filename);
 }
 
 int BIO_append_filename(BIO *bio, const char *filename) {
-  return BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_APPEND,
-                  (char *)filename);
+  return (int)BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_APPEND,
+                       (char *)filename);
 }
 
 int BIO_rw_filename(BIO *bio, const char *filename) {
-  return BIO_ctrl(bio, BIO_C_SET_FILENAME,
-                  BIO_CLOSE | BIO_FP_READ | BIO_FP_WRITE, (char *)filename);
+  return (int)BIO_ctrl(bio, BIO_C_SET_FILENAME,
+                       BIO_CLOSE | BIO_FP_READ | BIO_FP_WRITE,
+                       (char *)filename);
+}
+
+long BIO_tell(BIO *bio) { return BIO_ctrl(bio, BIO_C_FILE_TELL, 0, NULL); }
+
+long BIO_seek(BIO *bio, long offset) {
+  return BIO_ctrl(bio, BIO_C_FILE_SEEK, offset, NULL);
 }
 
 #endif  // OPENSSL_TRUSTY

data/third_party/boringssl-with-bazel/src/crypto/bio/pair.c

@@ -317,7 +317,6 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
     }
     b1->buf = OPENSSL_malloc(b1->size);
     if (b1->buf == NULL) {
-      OPENSSL_PUT_ERROR(BIO, ERR_R_MALLOC_FAILURE);
       return 0;
     }
     b1->len = 0;
@@ -330,7 +329,6 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
     }
     b2->buf = OPENSSL_malloc(b2->size);
     if (b2->buf == NULL) {
-      OPENSSL_PUT_ERROR(BIO, ERR_R_MALLOC_FAILURE);
       return 0;
     }
     b2->len = 0;
@@ -479,5 +477,5 @@ size_t BIO_ctrl_get_write_guarantee(BIO *bio) {
 }
 
 int BIO_shutdown_wr(BIO *bio) {
-  return BIO_ctrl(bio, BIO_C_SHUTDOWN_WR, 0, NULL);
+  return (int)BIO_ctrl(bio, BIO_C_SHUTDOWN_WR, 0, NULL);
 }

data/third_party/boringssl-with-bazel/src/crypto/bio/printf.c

@@ -71,18 +71,6 @@ int BIO_printf(BIO *bio, const char *format, ...) {
   va_start(args, format);
   out_len = vsnprintf(buf, sizeof(buf), format, args);
   va_end(args);
-
-#if defined(OPENSSL_WINDOWS)
-  // On Windows, vsnprintf returns -1 rather than the requested length on
-  // truncation
-  if (out_len < 0) {
-    va_start(args, format);
-    out_len = _vscprintf(format, args);
-    va_end(args);
-    assert(out_len >= (int)sizeof(buf));
-  }
-#endif
-
   if (out_len < 0) {
     return -1;
   }
@@ -95,7 +83,6 @@ int BIO_printf(BIO *bio, const char *format, ...) {
     out = OPENSSL_malloc(requested_len + 1);
     out_malloced = 1;
     if (out == NULL) {
-      OPENSSL_PUT_ERROR(BIO, ERR_R_MALLOC_FAILURE);
       return -1;
     }
     va_start(args, format);