grpc 1.69.0 → 1.71.0

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

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/bio.h>
 
@@ -73,7 +31,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 +74,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 +90,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 +128,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 +136,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 +158,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 +189,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 +217,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 +229,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 +258,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 +267,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 +368,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 +390,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 +421,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 +531,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 +540,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 +579,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 +589,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 +642,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}

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/bio.h>
 
@@ -83,7 +41,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 +93,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 +127,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 +143,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 +190,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 +201,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}

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/bio.h>
 
@@ -63,9 +21,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 +35,8 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 enum {
@@ -87,6 +45,7 @@ enum {
   BIO_CONN_S_OK,
 };
 
+namespace {
 typedef struct bio_connect_st {
   int state;
 
@@ -107,11 +66,10 @@ typedef struct bio_connect_st {
   // compatibility with the SSL info_callback.
   int (*info_callback)(const BIO *bio, int state, int ret);
 } BIO_CONNECT;
+}  // namespace
 
 #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 +189,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 +219,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 +255,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;
   }
@@ -305,10 +265,9 @@ static BIO_CONNECT *BIO_CONNECT_new(void) {
 }
 
 static void BIO_CONNECT_free(BIO_CONNECT *c) {
-  if (c == NULL) {
+  if (c == nullptr) {
     return;
   }
-
   OPENSSL_free(c->param_hostname);
   OPENSSL_free(c->param_port);
   OPENSSL_free(c);
@@ -323,7 +282,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 +301,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 +381,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 +425,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 +449,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 +487,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) {