grpc 1.69.0 → 1.71.0

data/third_party/boringssl-with-bazel/src/crypto/{ecdsa_extra/ecdsa_asn1.c → ecdsa/ecdsa_asn1.cc}

@@ -1,54 +1,16 @@
-/* ====================================================================
- * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
- *
- * 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 above 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 acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- *    endorse or promote products derived from this software without
- *    prior written permission. For written permission, please contact
- *    openssl-core@OpenSSL.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- *    nor may "OpenSSL" appear in their names without prior written
- *    permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- *    acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED 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 OpenSSL PROJECT OR
- * ITS 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.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com).  This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com). */
+// Copyright 2002-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/ecdsa.h>
 
@@ -57,8 +19,8 @@
 
 #include <openssl/bn.h>
 #include <openssl/bytestring.h>
-#include <openssl/err.h>
 #include <openssl/ec_key.h>
+#include <openssl/err.h>
 #include <openssl/mem.h>
 
 #include "../bytestring/internal.h"
@@ -79,8 +41,7 @@ static ECDSA_SIG *ecdsa_sig_from_fixed(const EC_KEY *key, const uint8_t *in,
     return NULL;
   }
   ECDSA_SIG *ret = ECDSA_SIG_new();
-  if (ret == NULL ||
-      !BN_bin2bn(in, scalar_len, ret->r) ||
+  if (ret == NULL || !BN_bin2bn(in, scalar_len, ret->r) ||
       !BN_bin2bn(in + scalar_len, scalar_len, ret->s)) {
     ECDSA_SIG_free(ret);
     return NULL;
@@ -100,8 +61,7 @@ static int ecdsa_sig_to_fixed(const EC_KEY *key, uint8_t *out, size_t *out_len,
     OPENSSL_PUT_ERROR(EC, EC_R_BUFFER_TOO_SMALL);
     return 0;
   }
-  if (BN_is_negative(sig->r) ||
-      !BN_bn2bin_padded(out, scalar_len, sig->r) ||
+  if (BN_is_negative(sig->r) || !BN_bn2bin_padded(out, scalar_len, sig->r) ||
       BN_is_negative(sig->s) ||
       !BN_bn2bin_padded(out + scalar_len, scalar_len, sig->s)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_BAD_SIGNATURE);
@@ -115,7 +75,7 @@ int ECDSA_sign(int type, const uint8_t *digest, size_t digest_len, uint8_t *sig,
                unsigned int *out_sig_len, const EC_KEY *eckey) {
   if (eckey->ecdsa_meth && eckey->ecdsa_meth->sign) {
     return eckey->ecdsa_meth->sign(digest, digest_len, sig, out_sig_len,
-                                   (EC_KEY*) eckey /* cast away const */);
+                                   (EC_KEY *)eckey /* cast away const */);
   }
 
   *out_sig_len = 0;
@@ -137,8 +97,7 @@ int ECDSA_sign(int type, const uint8_t *digest, size_t digest_len, uint8_t *sig,
   CBB cbb;
   CBB_init_fixed(&cbb, sig, ECDSA_size(eckey));
   size_t len;
-  if (!ECDSA_SIG_marshal(&cbb, s) ||
-      !CBB_finish(&cbb, NULL, &len)) {
+  if (!ECDSA_SIG_marshal(&cbb, s) || !CBB_finish(&cbb, NULL, &len)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
     goto err;
   }
@@ -165,8 +124,8 @@ int ECDSA_verify(int type, const uint8_t *digest, size_t digest_len,
 
   // Defend against potential laxness in the DER parser.
   size_t der_len;
-  if (!ECDSA_SIG_to_bytes(&der, &der_len, s) ||
-      der_len != sig_len || OPENSSL_memcmp(sig, der, sig_len) != 0) {
+  if (!ECDSA_SIG_to_bytes(&der, &der_len, s) || der_len != sig_len ||
+      OPENSSL_memcmp(sig, der, sig_len) != 0) {
     // This should never happen. crypto/bytestring is strictly DER.
     OPENSSL_PUT_ERROR(ECDSA, ERR_R_INTERNAL_ERROR);
     goto err;
@@ -189,23 +148,18 @@ size_t ECDSA_size(const EC_KEY *key) {
     return 0;
   }
 
-  size_t group_order_size;
-  if (key->ecdsa_meth && key->ecdsa_meth->group_order_size) {
-    group_order_size = key->ecdsa_meth->group_order_size(key);
-  } else {
-    const EC_GROUP *group = EC_KEY_get0_group(key);
-    if (group == NULL) {
-      return 0;
-    }
-
-    group_order_size = BN_num_bytes(EC_GROUP_get0_order(group));
+  const EC_GROUP *group = EC_KEY_get0_group(key);
+  if (group == NULL) {
+    return 0;
   }
 
+  size_t group_order_size = BN_num_bytes(EC_GROUP_get0_order(group));
   return ECDSA_SIG_max_len(group_order_size);
 }
 
 ECDSA_SIG *ECDSA_SIG_new(void) {
-  ECDSA_SIG *sig = OPENSSL_malloc(sizeof(ECDSA_SIG));
+  ECDSA_SIG *sig =
+      reinterpret_cast<ECDSA_SIG *>(OPENSSL_malloc(sizeof(ECDSA_SIG)));
   if (sig == NULL) {
     return NULL;
   }
@@ -228,13 +182,9 @@ void ECDSA_SIG_free(ECDSA_SIG *sig) {
   OPENSSL_free(sig);
 }
 
-const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig) {
-  return sig->r;
-}
+const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig) { return sig->r; }
 
-const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig) {
-  return sig->s;
-}
+const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig) { return sig->s; }
 
 void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **out_r,
                     const BIGNUM **out_s) {
@@ -301,8 +251,7 @@ ECDSA_SIG *ECDSA_SIG_parse(CBS *cbs) {
   CBS child;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
       !BN_parse_asn1_unsigned(&child, ret->r) ||
-      !BN_parse_asn1_unsigned(&child, ret->s) ||
-      CBS_len(&child) != 0) {
+      !BN_parse_asn1_unsigned(&child, ret->s) || CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_BAD_SIGNATURE);
     ECDSA_SIG_free(ret);
     return NULL;
@@ -325,8 +274,7 @@ ECDSA_SIG *ECDSA_SIG_from_bytes(const uint8_t *in, size_t in_len) {
 int ECDSA_SIG_marshal(CBB *cbb, const ECDSA_SIG *sig) {
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_SEQUENCE) ||
-      !BN_marshal_asn1(&child, sig->r) ||
-      !BN_marshal_asn1(&child, sig->s) ||
+      !BN_marshal_asn1(&child, sig->r) || !BN_marshal_asn1(&child, sig->s) ||
       !CBB_flush(cbb)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
     return 0;
@@ -338,8 +286,7 @@ int ECDSA_SIG_to_bytes(uint8_t **out_bytes, size_t *out_len,
                        const ECDSA_SIG *sig) {
   CBB cbb;
   CBB_zero(&cbb);
-  if (!CBB_init(&cbb, 0) ||
-      !ECDSA_SIG_marshal(&cbb, sig) ||
+  if (!CBB_init(&cbb, 0) || !ECDSA_SIG_marshal(&cbb, sig) ||
       !CBB_finish(&cbb, out_bytes, out_len)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
     CBB_cleanup(&cbb);
@@ -402,8 +349,7 @@ ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **out, const uint8_t **inp, long len) {
 
 int i2d_ECDSA_SIG(const ECDSA_SIG *sig, uint8_t **outp) {
   CBB cbb;
-  if (!CBB_init(&cbb, 0) ||
-      !ECDSA_SIG_marshal(&cbb, sig)) {
+  if (!CBB_init(&cbb, 0) || !ECDSA_SIG_marshal(&cbb, sig)) {
     CBB_cleanup(&cbb);
     return -1;
   }

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

@@ -1,21 +1,21 @@
-/* Copyright (c) 2014, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+// Copyright 2014 The BoringSSL Authors
+//
+// 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/engine.h>
 
-#include <string.h>
 #include <assert.h>
+#include <string.h>
 
 #include <openssl/ec_key.h>
 #include <openssl/err.h>
@@ -31,7 +31,9 @@ struct engine_st {
   ECDSA_METHOD *ecdsa_method;
 };
 
-ENGINE *ENGINE_new(void) { return OPENSSL_zalloc(sizeof(ENGINE)); }
+ENGINE *ENGINE_new(void) {
+  return reinterpret_cast<ENGINE *>(OPENSSL_zalloc(sizeof(ENGINE)));
+}
 
 int ENGINE_free(ENGINE *engine) {
   // Methods are currently required to be static so are not unref'ed.
@@ -46,17 +48,18 @@ int ENGINE_free(ENGINE *engine) {
 // static.
 static int set_method(void **out_member, const void *method, size_t method_size,
                       size_t compiled_size) {
-  const struct openssl_method_common_st *common = method;
+  const struct openssl_method_common_st *common =
+      reinterpret_cast<const openssl_method_common_st *>(method);
   if (method_size != compiled_size || !common->is_static) {
     return 0;
   }
 
-  *out_member = (void*) method;
+  *out_member = (void *)method;
   return 1;
 }
 
 int ENGINE_set_RSA_method(ENGINE *engine, const RSA_METHOD *method,
-                         size_t method_size) {
+                          size_t method_size) {
   return set_method((void **)&engine->rsa_method, method, method_size,
                     sizeof(RSA_METHOD));
 }
@@ -76,11 +79,12 @@ ECDSA_METHOD *ENGINE_get_ECDSA_method(const ENGINE *engine) {
 }
 
 void METHOD_ref(void *method_in) {
-  assert(((struct openssl_method_common_st*) method_in)->is_static);
+  assert(((struct openssl_method_common_st *)method_in)->is_static);
 }
 
 void METHOD_unref(void *method_in) {
-  struct openssl_method_common_st *method = method_in;
+  struct openssl_method_common_st *method =
+      reinterpret_cast<openssl_method_common_st *>(method_in);
 
   if (method == NULL) {
     return;

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

@@ -1,110 +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 (c) 1998-2006 The OpenSSL Project.  All rights reserved.
- *
- * 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 above 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 acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- *    endorse or promote products derived from this software without
- *    prior written permission. For written permission, please contact
- *    openssl-core@openssl.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- *    nor may "OpenSSL" appear in their names without prior written
- *    permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- *    acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED 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 OpenSSL PROJECT OR
- * ITS 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.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com).  This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com). */
+// 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.
 
 // Ensure we can't call OPENSSL_malloc circularly.
 #define _BORINGSSL_PROHIBIT_OPENSSL_MALLOC
@@ -130,6 +36,7 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
 #include "./internal.h"
 
 
+namespace {
 struct err_error_st {
   // file contains the filename where the error occurred.
   const char *file;
@@ -159,6 +66,7 @@ typedef struct err_state_st {
   // previously a |data| pointer of one of the elements of |errors|.
   void *to_free;
 } ERR_STATE;
+}  // namespace
 
 extern const uint32_t kOpenSSLReasonValues[];
 extern const size_t kOpenSSLReasonValuesLen;
@@ -168,7 +76,7 @@ static char *strdup_libc_malloc(const char *str) {
   // |strdup| is not in C until C23, so MSVC triggers deprecation warnings, and
   // glibc and musl gate it on a feature macro. Reimplementing it is easier.
   size_t len = strlen(str);
-  char *ret = malloc(len + 1);
+  char *ret = reinterpret_cast<char *>(malloc(len + 1));
   if (ret != NULL) {
     memcpy(ret, str, len + 1);
   }
@@ -202,7 +110,7 @@ static int global_next_library = ERR_NUM_LIBS;
 static CRYPTO_MUTEX global_next_library_mutex = CRYPTO_MUTEX_INIT;
 
 static void err_state_free(void *statep) {
-  ERR_STATE *state = statep;
+  ERR_STATE *state = reinterpret_cast<ERR_STATE *>(statep);
 
   if (state == NULL) {
     return;
@@ -217,9 +125,10 @@ static void err_state_free(void *statep) {
 
 // err_get_state gets the ERR_STATE object for the current thread.
 static ERR_STATE *err_get_state(void) {
-  ERR_STATE *state = CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_ERR);
+  ERR_STATE *state = reinterpret_cast<ERR_STATE *>(
+      CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_ERR));
   if (state == NULL) {
-    state = malloc(sizeof(ERR_STATE));
+    state = reinterpret_cast<ERR_STATE *>(malloc(sizeof(ERR_STATE)));
     if (state == NULL) {
       return NULL;
     }
@@ -380,19 +289,15 @@ int ERR_get_next_error_library(void) {
   return ret;
 }
 
-void ERR_remove_state(unsigned long pid) {
-  ERR_clear_error();
-}
+void ERR_remove_state(unsigned long pid) { ERR_clear_error(); }
 
-void ERR_clear_system_error(void) {
-  errno = 0;
-}
+void ERR_clear_system_error(void) { errno = 0; }
 
 // err_string_cmp is a compare function for searching error values with
 // |bsearch| in |err_string_lookup|.
 static int err_string_cmp(const void *a, const void *b) {
-  const uint32_t a_key = *((const uint32_t*) a) >> 15;
-  const uint32_t b_key = *((const uint32_t*) b) >> 15;
+  const uint32_t a_key = *((const uint32_t *)a) >> 15;
+  const uint32_t b_key = *((const uint32_t *)b) >> 15;
 
   if (a_key < b_key) {
     return -1;
@@ -406,8 +311,7 @@ static int err_string_cmp(const void *a, const void *b) {
 // err_string_lookup looks up the string associated with |lib| and |key| in
 // |values| and |string_data|. It returns the string or NULL if not found.
 static const char *err_string_lookup(uint32_t lib, uint32_t key,
-                                     const uint32_t *values,
-                                     size_t num_values,
+                                     const uint32_t *values, size_t num_values,
                                      const char *string_data) {
   // |values| points to data in err_data.h, which is generated by
   // err_data_generate.go. It's an array of uint32_t values. Each value has the
@@ -426,8 +330,8 @@ static const char *err_string_lookup(uint32_t lib, uint32_t key,
     return NULL;
   }
   uint32_t search_key = lib << 26 | key << 15;
-  const uint32_t *result = bsearch(&search_key, values, num_values,
-                                   sizeof(uint32_t), err_string_cmp);
+  const uint32_t *result = reinterpret_cast<const uint32_t *>(bsearch(
+      &search_key, values, num_values, sizeof(uint32_t), err_string_cmp));
   if (result == NULL) {
     return NULL;
   }
@@ -435,11 +339,13 @@ static const char *err_string_lookup(uint32_t lib, uint32_t key,
   return &string_data[(*result) & 0x7fff];
 }
 
+namespace {
 typedef struct library_name_st {
   const char *str;
   const char *symbol;
   const char *reason_symbol;
 } LIBRARY_NAME;
+}  // namespace
 
 static const LIBRARY_NAME kLibraryNames[ERR_NUM_LIBS] = {
     {"invalid library (0)", NULL, NULL},
@@ -632,7 +538,7 @@ void ERR_print_errors_cb(ERR_print_errors_callback_t callback, void *ctx) {
 
   // thread_hash is the least-significant bits of the |ERR_STATE| pointer value
   // for this thread.
-  const unsigned long thread_hash = (uintptr_t) err_get_state();
+  const unsigned long thread_hash = (uintptr_t)err_get_state();
 
   for (;;) {
     packed_error = ERR_get_error_line_data(&file, &line, &data, &flags);
@@ -649,9 +555,9 @@ void ERR_print_errors_cb(ERR_print_errors_callback_t callback, void *ctx) {
   }
 }
 
-static int print_errors_to_file(const char* msg, size_t msg_len, void* ctx) {
+static int print_errors_to_file(const char *msg, size_t msg_len, void *ctx) {
   assert(msg[msg_len] == '\0');
-  FILE* fp = ctx;
+  FILE *fp = reinterpret_cast<FILE *>(ctx);
   int res = fputs(msg, fp);
   return res < 0 ? 0 : 1;
 }
@@ -722,16 +628,16 @@ static void err_add_error_vdata(unsigned num, va_list args) {
     }
     size_t substr_len = strlen(substr);
     if (SIZE_MAX - total_size < substr_len) {
-      return; // Would overflow.
+      return;  // Would overflow.
     }
     total_size += substr_len;
   }
   va_end(args_copy);
   if (total_size == SIZE_MAX) {
-      return; // Would overflow.
+    return;  // Would overflow.
   }
-  total_size += 1; // NUL terminator.
-  if ((buf = malloc(total_size)) == NULL) {
+  total_size += 1;  // NUL terminator.
+  if ((buf = reinterpret_cast<char *>(malloc(total_size))) == NULL) {
     return;
   }
   buf[0] = '\0';
@@ -741,10 +647,9 @@ static void err_add_error_vdata(unsigned num, va_list args) {
       continue;
     }
     if (OPENSSL_strlcat(buf, substr, total_size) >= total_size) {
-      assert(0); // should not be possible.
+      assert(0);  // should not be possible.
     }
   }
-  va_end(args);
   err_set_error_data(buf);
 }
 
@@ -855,7 +760,8 @@ ERR_SAVE_STATE *ERR_save_state(void) {
     return NULL;
   }
 
-  ERR_SAVE_STATE *ret = malloc(sizeof(ERR_SAVE_STATE));
+  ERR_SAVE_STATE *ret =
+      reinterpret_cast<ERR_SAVE_STATE *>(malloc(sizeof(ERR_SAVE_STATE)));
   if (ret == NULL) {
     return NULL;
   }
@@ -865,7 +771,8 @@ ERR_SAVE_STATE *ERR_save_state(void) {
                           ? state->top - state->bottom
                           : ERR_NUM_ERRORS + state->top - state->bottom;
   assert(num_errors < ERR_NUM_ERRORS);
-  ret->errors = malloc(num_errors * sizeof(struct err_error_st));
+  ret->errors = reinterpret_cast<err_error_st *>(
+      malloc(num_errors * sizeof(struct err_error_st)));
   if (ret->errors == NULL) {
     free(ret);
     return NULL;

data/third_party/boringssl-with-bazel/src/crypto/err/internal.h

@@ -1,16 +1,16 @@
-/* Copyright (c) 2017, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+// Copyright 2017 The BoringSSL Authors
+//
+// 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.
 
 #ifndef OPENSSL_HEADER_CRYPTO_ERR_INTERNAL_H
 #define OPENSSL_HEADER_CRYPTO_ERR_INTERNAL_H