grpc 1.69.0 → 1.70.1

data/third_party/boringssl-with-bazel/src/crypto/asn1/{tasn_new.c → tasn_new.cc}

@@ -91,7 +91,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 
   switch (it->itype) {
     case ASN1_ITYPE_EXTERN:
-      ef = it->funcs;
+      ef = reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
       if (ef && ef->asn1_ex_new) {
         if (!ef->asn1_ex_new(pval, it)) {
           goto memerr;
@@ -116,7 +116,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
       break;
 
     case ASN1_ITYPE_CHOICE: {
-      const ASN1_AUX *aux = it->funcs;
+      const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
       ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
       if (asn1_cb) {
         i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
@@ -127,7 +127,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
           return 1;
         }
       }
-      *pval = OPENSSL_zalloc(it->size);
+      *pval = reinterpret_cast<ASN1_VALUE *>(OPENSSL_zalloc(it->size));
       if (!*pval) {
         goto memerr;
       }
@@ -139,7 +139,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
     }
 
     case ASN1_ITYPE_SEQUENCE: {
-      const ASN1_AUX *aux = it->funcs;
+      const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
       ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
       if (asn1_cb) {
         i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
@@ -150,7 +150,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
           return 1;
         }
       }
-      *pval = OPENSSL_zalloc(it->size);
+      *pval = reinterpret_cast<ASN1_VALUE *>(OPENSSL_zalloc(it->size));
       if (!*pval) {
         goto memerr;
       }
@@ -279,7 +279,8 @@ static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
       return 1;
 
     case V_ASN1_ANY: {
-      ASN1_TYPE *typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
+      ASN1_TYPE *typ =
+          reinterpret_cast<ASN1_TYPE *>(OPENSSL_malloc(sizeof(ASN1_TYPE)));
       if (!typ) {
         return 0;
       }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{tasn_utl.c → tasn_utl.cc}

@@ -77,7 +77,7 @@
 
 // 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);
+  int *sel = reinterpret_cast<int *>(offset2ptr(*pval, it->utype));
   return *sel;
 }
 
@@ -85,7 +85,7 @@ int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 int asn1_set_choice_selector(ASN1_VALUE **pval, int value,
                              const ASN1_ITEM *it) {
   int *sel, ret;
-  sel = offset2ptr(*pval, it->utype);
+  sel = reinterpret_cast<int *>(offset2ptr(*pval, it->utype));
   ret = *sel;
   *sel = value;
   return ret;
@@ -96,11 +96,12 @@ static CRYPTO_refcount_t *asn1_get_references(ASN1_VALUE **pval,
   if (it->itype != ASN1_ITYPE_SEQUENCE) {
     return NULL;
   }
-  const ASN1_AUX *aux = it->funcs;
+  const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
   if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT)) {
     return NULL;
   }
-  return offset2ptr(*pval, aux->ref_offset);
+  return reinterpret_cast<CRYPTO_refcount_t *>(
+      offset2ptr(*pval, aux->ref_offset));
 }
 
 void asn1_refcount_set_one(ASN1_VALUE **pval, const ASN1_ITEM *it) {
@@ -124,11 +125,11 @@ static ASN1_ENCODING *asn1_get_enc_ptr(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   if (!pval || !*pval) {
     return NULL;
   }
-  aux = it->funcs;
+  aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
   if (!aux || !(aux->flags & ASN1_AFLG_ENCODING)) {
     return NULL;
   }
-  return offset2ptr(*pval, aux->enc_offset);
+  return reinterpret_cast<ASN1_ENCODING *>(offset2ptr(*pval, aux->enc_offset));
 }
 
 void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it) {
@@ -163,7 +164,7 @@ int asn1_enc_save(ASN1_VALUE **pval, const uint8_t *in, size_t in_len,
     enc->buf = buf;
     enc->enc = (uint8_t *)in;
   } else {
-    enc->enc = OPENSSL_memdup(in, in_len);
+    enc->enc = reinterpret_cast<uint8_t *>(OPENSSL_memdup(in, in_len));
     if (!enc->enc) {
       return 0;
     }
@@ -202,7 +203,8 @@ int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
 
 // 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 = offset2ptr(*pval, tt->offset);
+  ASN1_VALUE **pvaltmp =
+      reinterpret_cast<ASN1_VALUE **>(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;
@@ -224,9 +226,10 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
   adb = ASN1_ADB_ptr(tt->item);
 
   // Get the selector field
-  sfld = offset2ptr(*pval, adb->offset);
+  sfld = reinterpret_cast<ASN1_VALUE **>(offset2ptr(*pval, adb->offset));
 
   // Check if NULL
+  int selector;
   if (*sfld == NULL) {
     if (!adb->null_tt) {
       goto err;
@@ -238,7 +241,7 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
   // 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);
+  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

data/third_party/boringssl-with-bazel/src/crypto/base64/{base64.c → base64.cc}

@@ -121,12 +121,11 @@ int EVP_EncodedLength(size_t *out_len, size_t len) {
 }
 
 EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void) {
-  return OPENSSL_zalloc(sizeof(EVP_ENCODE_CTX));
+  return reinterpret_cast<EVP_ENCODE_CTX *>(
+      OPENSSL_zalloc(sizeof(EVP_ENCODE_CTX)));
 }
 
-void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx) {
-  OPENSSL_free(ctx);
-}
+void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx) { OPENSSL_free(ctx); }
 
 void EVP_EncodeInit(EVP_ENCODE_CTX *ctx) {
   OPENSSL_memset(ctx, 0, sizeof(EVP_ENCODE_CTX));
@@ -302,9 +301,9 @@ static int base64_decode_quad(uint8_t *out, size_t *out_num_bytes,
   const uint32_t v = ((uint32_t)a) << 18 | ((uint32_t)b) << 12 |
                      ((uint32_t)c) << 6 | (uint32_t)d;
 
-  const unsigned padding_pattern = (in[0] == '=') << 3 |
-                                   (in[1] == '=') << 2 |
-                                   (in[2] == '=') << 1 |
+  const unsigned padding_pattern = (in[0] == '=') << 3 | //
+                                   (in[1] == '=') << 2 | //
+                                   (in[2] == '=') << 1 | //
                                    (in[3] == '=');
 
   // In presence of padding, the lowest bits of v are unused. Canonical encoding
@@ -412,8 +411,7 @@ int EVP_DecodeBase64(uint8_t *out, size_t *out_len, size_t max_out,
   }
 
   size_t max_len;
-  if (!EVP_DecodedLength(&max_len, in_len) ||
-      max_out < max_len) {
+  if (!EVP_DecodedLength(&max_len, in_len) || max_out < max_len) {
     return 0;
   }
 
@@ -449,7 +447,7 @@ int EVP_DecodeBlock(uint8_t *dst, const uint8_t *src, size_t src_len) {
 
   // Trim newlines, spaces and tabs from the end of the line.
   while (src_len > 0) {
-    switch (src[src_len-1]) {
+    switch (src[src_len - 1]) {
       case ' ':
       case '\t':
       case '\r':
@@ -462,8 +460,7 @@ int EVP_DecodeBlock(uint8_t *dst, const uint8_t *src, size_t src_len) {
   }
 
   size_t dst_len;
-  if (!EVP_DecodedLength(&dst_len, src_len) ||
-      dst_len > INT_MAX ||
+  if (!EVP_DecodedLength(&dst_len, src_len) || dst_len > INT_MAX ||
       !EVP_DecodeBase64(dst, &dst_len, dst_len, src, src_len)) {
     return -1;
   }

data/third_party/boringssl-with-bazel/src/crypto/bcm_support.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2024, Google Inc.
+/* Copyright 2024 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -17,6 +17,8 @@
 
 #include <openssl/base.h>
 
+#include <stdio.h>
+
 // Provided by libcrypto, called from BCM
 
 #if defined(__cplusplus)
@@ -105,6 +107,10 @@ OPENSSL_EXPORT uint64_t CRYPTO_get_fork_generation(void);
 OPENSSL_EXPORT void CRYPTO_fork_detect_force_madv_wipeonfork_for_testing(
     int on);
 
+// CRYPTO_get_stderr returns stderr. This function exists to avoid BCM needing
+// a data dependency on libc.
+FILE *CRYPTO_get_stderr(void);
+
 
 #if defined(__cplusplus)
 }  // extern C

data/third_party/boringssl-with-bazel/src/crypto/bio/{bio.c → bio.cc}

@@ -73,7 +73,7 @@ static CRYPTO_EX_DATA_CLASS g_ex_data_class =
     CRYPTO_EX_DATA_CLASS_INIT_WITH_APP_DATA;
 
 BIO *BIO_new(const BIO_METHOD *method) {
-  BIO *ret = OPENSSL_zalloc(sizeof(BIO));
+  BIO *ret = reinterpret_cast<BIO *>(OPENSSL_zalloc(sizeof(BIO)));
   if (ret == NULL) {
     return NULL;
   }
@@ -116,13 +116,9 @@ int BIO_up_ref(BIO *bio) {
   return 1;
 }
 
-void BIO_vfree(BIO *bio) {
-  BIO_free(bio);
-}
+void BIO_vfree(BIO *bio) { BIO_free(bio); }
 
-void BIO_free_all(BIO *bio) {
-  BIO_free(bio);
-}
+void BIO_free_all(BIO *bio) { BIO_free(bio); }
 
 int BIO_read(BIO *bio, void *buf, int len) {
   if (bio == NULL || bio->method == NULL || bio->method->bread == NULL) {
@@ -136,7 +132,7 @@ int BIO_read(BIO *bio, void *buf, int len) {
   if (len <= 0) {
     return 0;
   }
-  int ret = bio->method->bread(bio, buf, len);
+  int ret = bio->method->bread(bio, reinterpret_cast<char *>(buf), len);
   if (ret > 0) {
     bio->num_read += ret;
   }
@@ -174,7 +170,7 @@ int BIO_write(BIO *bio, const void *in, int inl) {
   if (inl <= 0) {
     return 0;
   }
-  int ret = bio->method->bwrite(bio, in, inl);
+  int ret = bio->method->bwrite(bio, reinterpret_cast<const char *>(in), inl);
   if (ret > 0) {
     bio->num_write += ret;
   }
@@ -182,7 +178,7 @@ int BIO_write(BIO *bio, const void *in, int inl) {
 }
 
 int BIO_write_all(BIO *bio, const void *data, size_t len) {
-  const uint8_t *data_u8 = data;
+  const uint8_t *data_u8 = reinterpret_cast<const uint8_t *>(data);
   while (len > 0) {
     int ret = BIO_write(bio, data_u8, len > INT_MAX ? INT_MAX : (int)len);
     if (ret <= 0) {
@@ -204,9 +200,7 @@ int BIO_puts(BIO *bio, const char *in) {
   return BIO_write(bio, in, (int)len);
 }
 
-int BIO_flush(BIO *bio) {
-  return (int)BIO_ctrl(bio, BIO_CTRL_FLUSH, 0, NULL);
-}
+int BIO_flush(BIO *bio) { return (int)BIO_ctrl(bio, BIO_CTRL_FLUSH, 0, NULL); }
 
 long BIO_ctrl(BIO *bio, int cmd, long larg, void *parg) {
   if (bio == NULL) {
@@ -237,21 +231,13 @@ long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) {
   return BIO_ctrl(b, cmd, larg, (void *)&i);
 }
 
-int BIO_reset(BIO *bio) {
-  return (int)BIO_ctrl(bio, BIO_CTRL_RESET, 0, NULL);
-}
+int BIO_reset(BIO *bio) { return (int)BIO_ctrl(bio, BIO_CTRL_RESET, 0, NULL); }
 
-int BIO_eof(BIO *bio) {
-  return (int)BIO_ctrl(bio, BIO_CTRL_EOF, 0, NULL);
-}
+int BIO_eof(BIO *bio) { return (int)BIO_ctrl(bio, BIO_CTRL_EOF, 0, NULL); }
 
-void BIO_set_flags(BIO *bio, int flags) {
-  bio->flags |= flags;
-}
+void BIO_set_flags(BIO *bio, int flags) { bio->flags |= flags; }
 
-int BIO_test_flags(const BIO *bio, int flags) {
-  return bio->flags & flags;
-}
+int BIO_test_flags(const BIO *bio, int flags) { return bio->flags & flags; }
 
 int BIO_should_read(const BIO *bio) {
   return BIO_test_flags(bio, BIO_FLAGS_READ);
@@ -273,9 +259,7 @@ int BIO_get_retry_reason(const BIO *bio) { return bio->retry_reason; }
 
 void BIO_set_retry_reason(BIO *bio, int reason) { bio->retry_reason = reason; }
 
-void BIO_clear_flags(BIO *bio, int flags) {
-  bio->flags &= ~flags;
-}
+void BIO_clear_flags(BIO *bio, int flags) { bio->flags &= ~flags; }
 
 void BIO_set_retry_read(BIO *bio) {
   bio->flags |= BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY;
@@ -287,9 +271,7 @@ void BIO_set_retry_write(BIO *bio) {
 
 static const int kRetryFlags = BIO_FLAGS_RWS | BIO_FLAGS_SHOULD_RETRY;
 
-int BIO_get_retry_flags(BIO *bio) {
-  return bio->flags & kRetryFlags;
-}
+int BIO_get_retry_flags(BIO *bio) { return bio->flags & kRetryFlags; }
 
 void BIO_clear_retry_flags(BIO *bio) {
   bio->flags &= ~kRetryFlags;
@@ -318,7 +300,7 @@ long BIO_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
 }
 
 size_t BIO_pending(const BIO *bio) {
-  const long r = BIO_ctrl((BIO *) bio, BIO_CTRL_PENDING, 0, NULL);
+  const long r = BIO_ctrl((BIO *)bio, BIO_CTRL_PENDING, 0, NULL);
   assert(r >= 0);
 
   if (r < 0) {
@@ -327,12 +309,10 @@ size_t BIO_pending(const BIO *bio) {
   return r;
 }
 
-size_t BIO_ctrl_pending(const BIO *bio) {
-  return BIO_pending(bio);
-}
+size_t BIO_ctrl_pending(const BIO *bio) { return BIO_pending(bio); }
 
 size_t BIO_wpending(const BIO *bio) {
-  const long r = BIO_ctrl((BIO *) bio, BIO_CTRL_WPENDING, 0, NULL);
+  const long r = BIO_ctrl((BIO *)bio, BIO_CTRL_WPENDING, 0, NULL);
   assert(r >= 0);
 
   if (r < 0) {
@@ -430,9 +410,7 @@ static int print_bio(const char *str, size_t len, void *bio) {
   return BIO_write_all((BIO *)bio, str, len);
 }
 
-void ERR_print_errors(BIO *bio) {
-  ERR_print_errors_cb(print_bio, bio);
-}
+void ERR_print_errors(BIO *bio) { ERR_print_errors_cb(print_bio, bio); }
 
 // bio_read_all reads everything from |bio| and prepends |prefix| to it. On
 // success, |*out| is set to an allocated buffer (which should be freed with
@@ -454,7 +432,7 @@ static int bio_read_all(BIO *bio, uint8_t **out, size_t *out_len,
   if (len < prefix_len) {
     return 0;
   }
-  *out = OPENSSL_malloc(len);
+  *out = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
   if (*out == NULL) {
     return 0;
   }
@@ -485,7 +463,8 @@ static int bio_read_all(BIO *bio, uint8_t **out, size_t *out_len,
       if (len < kChunkSize || len > max_len) {
         len = max_len;
       }
-      uint8_t *new_buf = OPENSSL_realloc(*out, len);
+      uint8_t *new_buf =
+          reinterpret_cast<uint8_t *>(OPENSSL_realloc(*out, len));
       if (new_buf == NULL) {
         OPENSSL_free(*out);
         return 0;
@@ -594,7 +573,7 @@ int BIO_read_asn1(BIO *bio, uint8_t **out, size_t *out_len, size_t max_len) {
       return 0;
     }
 
-    if ((len32 >> ((num_bytes-1)*8)) == 0) {
+    if ((len32 >> ((num_bytes - 1) * 8)) == 0) {
       // Length should have been at least one byte shorter.
       OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
       return 0;
@@ -603,16 +582,14 @@ int BIO_read_asn1(BIO *bio, uint8_t **out, size_t *out_len, size_t max_len) {
     len = len32;
   }
 
-  if (len + header_len < len ||
-      len + header_len > max_len ||
-      len > INT_MAX) {
+  if (len + header_len < len || len + header_len > max_len || len > INT_MAX) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_TOO_LONG);
     return 0;
   }
   len += header_len;
   *out_len = len;
 
-  *out = OPENSSL_malloc(len);
+  *out = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
   if (*out == NULL) {
     return 0;
   }
@@ -644,7 +621,8 @@ int BIO_get_new_index(void) {
 }
 
 BIO_METHOD *BIO_meth_new(int type, const char *name) {
-  BIO_METHOD *method = OPENSSL_zalloc(sizeof(BIO_METHOD));
+  BIO_METHOD *method =
+      reinterpret_cast<BIO_METHOD *>(OPENSSL_zalloc(sizeof(BIO_METHOD)));
   if (method == NULL) {
     return NULL;
   }
@@ -653,18 +631,14 @@ BIO_METHOD *BIO_meth_new(int type, const char *name) {
   return method;
 }
 
-void BIO_meth_free(BIO_METHOD *method) {
-  OPENSSL_free(method);
-}
+void BIO_meth_free(BIO_METHOD *method) { OPENSSL_free(method); }
 
-int BIO_meth_set_create(BIO_METHOD *method,
-                        int (*create_func)(BIO *)) {
+int BIO_meth_set_create(BIO_METHOD *method, int (*create_func)(BIO *)) {
   method->create = create_func;
   return 1;
 }
 
-int BIO_meth_set_destroy(BIO_METHOD *method,
-                         int (*destroy_func)(BIO *)) {
+int BIO_meth_set_destroy(BIO_METHOD *method, int (*destroy_func)(BIO *)) {
   method->destroy = destroy_func;
   return 1;
 }
@@ -710,10 +684,10 @@ int BIO_meth_set_puts(BIO_METHOD *method, int (*puts)(BIO *, const char *)) {
   return 1;
 }
 
-int BIO_get_ex_new_index(long argl, void *argp,
-                                    CRYPTO_EX_unused *unused,
-                                    CRYPTO_EX_dup *dup_unused,
-                                    CRYPTO_EX_free *free_func) {
+int BIO_get_ex_new_index(long argl, void *argp,      //
+                         CRYPTO_EX_unused *unused,   //
+                         CRYPTO_EX_dup *dup_unused,  //
+                         CRYPTO_EX_free *free_func) {
   return CRYPTO_get_ex_new_index_ex(&g_ex_data_class, argl, argp, free_func);
 }
 

data/third_party/boringssl-with-bazel/src/crypto/bio/{bio_mem.c → bio_mem.cc}

@@ -83,7 +83,7 @@ BIO *BIO_new_mem_buf(const void *buf, ossl_ssize_t len) {
 
   b = (BUF_MEM *)ret->ptr;
   // BIO_FLAGS_MEM_RDONLY ensures |b->data| is not written to.
-  b->data = (void *)buf;
+  b->data = reinterpret_cast<char *>(const_cast<void *>(buf));
   b->length = size;
   b->max = size;
 
@@ -135,7 +135,7 @@ static int mem_read(BIO *bio, char *out, int outl) {
     return 0;
   }
 
-  BUF_MEM *b = bio->ptr;
+  BUF_MEM *b = reinterpret_cast<BUF_MEM *>(bio->ptr);
   int ret = outl;
   if ((size_t)ret > b->length) {
     ret = (int)b->length;
@@ -169,7 +169,7 @@ static int mem_write(BIO *bio, const char *in, int inl) {
     return -1;
   }
 
-  BUF_MEM *b = bio->ptr;
+  BUF_MEM *b = reinterpret_cast<BUF_MEM *>(bio->ptr);
   if (!BUF_MEM_append(b, in, inl)) {
     return -1;
   }
@@ -185,14 +185,15 @@ 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.
-  BUF_MEM *b = bio->ptr;
+  BUF_MEM *b = reinterpret_cast<BUF_MEM *>(bio->ptr);
   int ret = size - 1;
   if ((size_t)ret > b->length) {
     ret = (int)b->length;
   }
 
   // Stop at the first newline.
-  const char *newline = OPENSSL_memchr(b->data, '\n', ret);
+  const char *newline =
+      reinterpret_cast<char *>(OPENSSL_memchr(b->data, '\n', ret));
   if (newline != NULL) {
     ret = (int)(newline - b->data + 1);
   }
@@ -231,7 +232,7 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
     case BIO_CTRL_INFO:
       ret = (long)b->length;
       if (ptr != NULL) {
-        char **pptr = ptr;
+        char **pptr = reinterpret_cast<char **>(ptr);
         *pptr = b->data;
       }
       break;
@@ -242,7 +243,7 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
       break;
     case BIO_C_GET_BUF_MEM_PTR:
       if (ptr != NULL) {
-        BUF_MEM **pptr = ptr;
+        BUF_MEM **pptr = reinterpret_cast<BUF_MEM **>(ptr);
         *pptr = b;
       }
       break;

data/third_party/boringssl-with-bazel/src/crypto/bio/{connect.c → connect.cc}

@@ -63,9 +63,9 @@
 #include <string.h>
 
 #if !defined(OPENSSL_WINDOWS)
-#include <sys/socket.h>
-#include <netinet/in.h>
 #include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
 #include <unistd.h>
 #else
 OPENSSL_MSVC_PRAGMA(warning(push, 3))
@@ -77,8 +77,8 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 enum {
@@ -109,9 +109,7 @@ typedef struct bio_connect_st {
 } BIO_CONNECT;
 
 #if !defined(OPENSSL_WINDOWS)
-static int closesocket(int sock) {
-  return close(sock);
-}
+static int closesocket(int sock) { return close(sock); }
 #endif
 
 // split_host_and_port sets |*out_host| and |*out_port| to the host and port
@@ -231,7 +229,7 @@ static int conn_state(BIO *bio, BIO_CONNECT *c) {
         }
 
         BIO_clear_retry_flags(bio);
-        ret = connect(bio->num, (struct sockaddr*) &c->them, c->them_length);
+        ret = connect(bio->num, (struct sockaddr *)&c->them, c->them_length);
         if (ret < 0) {
           if (bio_socket_should_retry(ret)) {
             BIO_set_flags(bio, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY));
@@ -261,7 +259,8 @@ static int conn_state(BIO *bio, BIO_CONNECT *c) {
             BIO_clear_retry_flags(bio);
             OPENSSL_PUT_SYSTEM_ERROR();
             OPENSSL_PUT_ERROR(BIO, BIO_R_NBIO_CONNECT_ERROR);
-            ERR_add_error_data(4, "host=", c->param_hostname, ":", c->param_port);
+            ERR_add_error_data(4, "host=", c->param_hostname, ":",
+                               c->param_port);
             ret = 0;
           }
           goto exit_loop;
@@ -296,7 +295,8 @@ end:
 }
 
 static BIO_CONNECT *BIO_CONNECT_new(void) {
-  BIO_CONNECT *ret = OPENSSL_zalloc(sizeof(BIO_CONNECT));
+  BIO_CONNECT *ret =
+      reinterpret_cast<BIO_CONNECT *>(OPENSSL_zalloc(sizeof(BIO_CONNECT)));
   if (ret == NULL) {
     return NULL;
   }
@@ -323,7 +323,7 @@ static int conn_new(BIO *bio) {
 }
 
 static void conn_close_socket(BIO *bio) {
-  BIO_CONNECT *c = (BIO_CONNECT *) bio->ptr;
+  BIO_CONNECT *c = (BIO_CONNECT *)bio->ptr;
 
   if (bio->num == -1) {
     return;
@@ -342,7 +342,7 @@ static int conn_free(BIO *bio) {
     conn_close_socket(bio);
   }
 
-  BIO_CONNECT_free((BIO_CONNECT*) bio->ptr);
+  BIO_CONNECT_free((BIO_CONNECT *)bio->ptr);
 
   return 1;
 }
@@ -422,13 +422,15 @@ static long conn_ctrl(BIO *bio, int cmd, long num, void *ptr) {
         bio->init = 1;
         if (num == 0) {
           OPENSSL_free(data->param_hostname);
-          data->param_hostname = OPENSSL_strdup(ptr);
+          data->param_hostname =
+              OPENSSL_strdup(reinterpret_cast<const char *>(ptr));
           if (data->param_hostname == NULL) {
             ret = 0;
           }
         } else if (num == 1) {
           OPENSSL_free(data->param_port);
-          data->param_port = OPENSSL_strdup(ptr);
+          data->param_port =
+              OPENSSL_strdup(reinterpret_cast<const char *>(ptr));
           if (data->param_port == NULL) {
             ret = 0;
           }
@@ -464,7 +466,8 @@ 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) = ptr;
+      int (**fptr)(const BIO *bio, int state, int xret);
+      fptr = reinterpret_cast<decltype(fptr)>(ptr);
       *fptr = data->info_callback;
     } break;
     default:
@@ -487,7 +490,12 @@ static long conn_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
       // convention.
       OPENSSL_MSVC_PRAGMA(warning(push))
       OPENSSL_MSVC_PRAGMA(warning(disable : 4191))
+      OPENSSL_CLANG_PRAGMA("clang diagnostic push")
+      OPENSSL_CLANG_PRAGMA(
+          "clang diagnostic ignored \"-Wunknown-warning-option\"")
+      OPENSSL_CLANG_PRAGMA("clang diagnostic ignored \"-Wcast-function-type\"")
       data->info_callback = (int (*)(const struct bio_st *, int, int))fp;
+      OPENSSL_CLANG_PRAGMA("clang diagnostic pop")
       OPENSSL_MSVC_PRAGMA(warning(pop))
       break;
     default:
@@ -520,11 +528,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 (int)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 (int)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) {

data/third_party/boringssl-with-bazel/src/crypto/bio/{file.c → file.cc}

@@ -143,7 +143,7 @@ static int file_free(BIO *bio) {
   }
 
   if (bio->init && bio->ptr != NULL) {
-    fclose(bio->ptr);
+    fclose(reinterpret_cast<FILE *>(bio->ptr));
     bio->ptr = NULL;
   }
   bio->init = 0;
@@ -208,7 +208,7 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
       // tested under POSIX will inadvertently change the state of |FILE|
       // objects when wrapping them in a |BIO|.
       if (num & BIO_FP_TEXT) {
-        _setmode(_fileno(ptr), _O_TEXT);
+        _setmode(_fileno(reinterpret_cast<FILE *>(ptr)), _O_TEXT);
       }
 #endif
       b->shutdown = (int)num & BIO_CLOSE;
@@ -236,7 +236,7 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
         ret = 0;
         break;
       }
-      fp = fopen_if_available(ptr, mode);
+      fp = fopen_if_available(reinterpret_cast<const char *>(ptr), mode);
       if (fp == NULL) {
         OPENSSL_PUT_SYSTEM_ERROR();
         ERR_add_error_data(5, "fopen('", ptr, "','", mode, "')");