grpc 1.69.0 → 1.70.1

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

@@ -81,7 +81,8 @@ struct bio_bio_st {
 };
 
 static int bio_new(BIO *bio) {
-  struct bio_bio_st *b = OPENSSL_zalloc(sizeof *b);
+  struct bio_bio_st *b =
+      reinterpret_cast<bio_bio_st *>(OPENSSL_zalloc(sizeof *b));
   if (b == NULL) {
     return 0;
   }
@@ -92,7 +93,7 @@ static int bio_new(BIO *bio) {
 }
 
 static void bio_destroy_pair(BIO *bio) {
-  struct bio_bio_st *b = bio->ptr;
+  struct bio_bio_st *b = reinterpret_cast<bio_bio_st *>(bio->ptr);
   BIO *peer_bio;
   struct bio_bio_st *peer_b;
 
@@ -105,7 +106,7 @@ static void bio_destroy_pair(BIO *bio) {
     return;
   }
 
-  peer_b = peer_bio->ptr;
+  peer_b = reinterpret_cast<bio_bio_st *>(peer_bio->ptr);
 
   assert(peer_b != NULL);
   assert(peer_b->peer == bio);
@@ -124,7 +125,7 @@ static void bio_destroy_pair(BIO *bio) {
 }
 
 static int bio_free(BIO *bio) {
-  struct bio_bio_st *b = bio->ptr;
+  struct bio_bio_st *b = reinterpret_cast<bio_bio_st *>(bio->ptr);
 
   assert(b != NULL);
 
@@ -149,10 +150,10 @@ static int bio_read(BIO *bio, char *buf, int size_) {
     return 0;
   }
 
-  b = bio->ptr;
+  b = reinterpret_cast<bio_bio_st *>(bio->ptr);
   assert(b != NULL);
   assert(b->peer != NULL);
-  peer_b = b->peer->ptr;
+  peer_b = reinterpret_cast<bio_bio_st *>(b->peer->ptr);
   assert(peer_b != NULL);
   assert(peer_b->buf != NULL);
 
@@ -233,7 +234,7 @@ static int bio_write(BIO *bio, const char *buf, int num_) {
     return 0;
   }
 
-  b = bio->ptr;
+  b = reinterpret_cast<bio_bio_st *>(bio->ptr);
   assert(b != NULL);
   assert(b->peer != NULL);
   assert(b->buf != NULL);
@@ -302,8 +303,8 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
   assert(bio1 != NULL);
   assert(bio2 != NULL);
 
-  b1 = bio1->ptr;
-  b2 = bio2->ptr;
+  b1 = reinterpret_cast<bio_bio_st *>(bio1->ptr);
+  b2 = reinterpret_cast<bio_bio_st *>(bio2->ptr);
 
   if (b1->peer != NULL || b2->peer != NULL) {
     OPENSSL_PUT_ERROR(BIO, BIO_R_IN_USE);
@@ -314,7 +315,7 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
     if (writebuf1_len) {
       b1->size = writebuf1_len;
     }
-    b1->buf = OPENSSL_malloc(b1->size);
+    b1->buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(b1->size));
     if (b1->buf == NULL) {
       return 0;
     }
@@ -326,7 +327,7 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
     if (writebuf2_len) {
       b2->size = writebuf2_len;
     }
-    b2->buf = OPENSSL_malloc(b2->size);
+    b2->buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(b2->size));
     if (b2->buf == NULL) {
       return 0;
     }
@@ -349,13 +350,12 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
 
 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
   long ret;
-  struct bio_bio_st *b = bio->ptr;
+  struct bio_bio_st *b = reinterpret_cast<bio_bio_st *>(bio->ptr);
 
   assert(b != NULL);
 
   switch (cmd) {
-    // specific CTRL codes
-
+    // Specific control codes first:
     case BIO_C_GET_WRITE_BUF_SIZE:
       ret = (long)b->size;
       break;
@@ -392,8 +392,8 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
       ret = 1;
       break;
 
-    // standard CTRL codes follow
 
+    // Standard control codes:
     case BIO_CTRL_GET_CLOSE:
       ret = bio->shutdown;
       break;
@@ -405,7 +405,8 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
 
     case BIO_CTRL_PENDING:
       if (b->peer != NULL) {
-        struct bio_bio_st *peer_b = b->peer->ptr;
+        struct bio_bio_st *peer_b =
+            reinterpret_cast<bio_bio_st *>(b->peer->ptr);
         ret = (long)peer_b->len;
       } else {
         ret = 0;
@@ -424,10 +425,11 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
       break;
 
     case BIO_CTRL_EOF: {
-      BIO *other_bio = ptr;
+      BIO *other_bio = reinterpret_cast<BIO *>(ptr);
 
       if (other_bio) {
-        struct bio_bio_st *other_b = other_bio->ptr;
+        struct bio_bio_st *other_b =
+            reinterpret_cast<bio_bio_st *>(other_bio->ptr);
         assert(other_b != NULL);
         ret = other_b->len == 0 && other_b->closed;
       } else {
@@ -449,8 +451,8 @@ static const BIO_METHOD methods_biop = {
 
 static const BIO_METHOD *bio_s_bio(void) { return &methods_biop; }
 
-int BIO_new_bio_pair(BIO** bio1_p, size_t writebuf1_len,
-                     BIO** bio2_p, size_t writebuf2_len) {
+int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1_len, BIO **bio2_p,
+                     size_t writebuf2_len) {
   BIO *bio1 = BIO_new(bio_s_bio());
   BIO *bio2 = BIO_new(bio_s_bio());
   if (bio1 == NULL || bio2 == NULL ||

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

@@ -75,12 +75,12 @@ int BIO_printf(BIO *bio, const char *format, ...) {
     return -1;
   }
 
-  if ((size_t) out_len >= sizeof(buf)) {
+  if ((size_t)out_len >= sizeof(buf)) {
     const int requested_len = out_len;
     // The output was truncated. Note that vsnprintf's return value
     // does not include a trailing NUL, but the buffer must be sized
     // for it.
-    out = OPENSSL_malloc(requested_len + 1);
+    out = reinterpret_cast<char *>(OPENSSL_malloc(requested_len + 1));
     out_malloced = 1;
     if (out == NULL) {
       return -1;

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 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

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2021, Google Inc.
+/* Copyright 2021 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
@@ -121,7 +121,7 @@ void BLAKE2B256_Update(BLAKE2B_CTX *b2b, const void *in_data, size_t len) {
     return;
   }
 
-  const uint8_t *data = in_data;
+  const uint8_t *data = reinterpret_cast<const uint8_t *>(in_data);
   size_t todo = sizeof(b2b->block) - b2b->block_used;
   if (todo > len) {
     todo = len;

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2015, Google Inc.
+/* Copyright 2015 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

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

@@ -78,8 +78,9 @@ static const char hextable[] = "0123456789abcdef";
 
 char *BN_bn2hex(const BIGNUM *bn) {
   int width = bn_minimal_width(bn);
-  char *buf = OPENSSL_malloc(1 /* leading '-' */ + 1 /* zero is non-empty */ +
-                             width * BN_BYTES * 2 + 1 /* trailing NUL */);
+  char *buf = reinterpret_cast<char *>(
+      OPENSSL_malloc(1 /* leading '-' */ + 1 /* zero is non-empty */ +
+                     width * BN_BYTES * 2 + 1 /* trailing NUL */));
   if (buf == NULL) {
     return NULL;
   }
@@ -112,7 +113,7 @@ char *BN_bn2hex(const BIGNUM *bn) {
 
 // decode_hex decodes |in_len| bytes of hex data from |in| and updates |bn|.
 static int decode_hex(BIGNUM *bn, const char *in, int in_len) {
-  if (in_len > INT_MAX/4) {
+  if (in_len > INT_MAX / 4) {
     OPENSSL_PUT_ERROR(BN, BN_R_BIGNUM_TOO_LONG);
     return 0;
   }
@@ -163,8 +164,7 @@ static int decode_dec(BIGNUM *bn, const char *in, int in_len) {
     l *= 10;
     l += in[i] - '0';
     if (++j == BN_DEC_NUM) {
-      if (!BN_mul_word(bn, BN_DEC_CONV) ||
-          !BN_add_word(bn, l)) {
+      if (!BN_mul_word(bn, BN_DEC_CONV) || !BN_add_word(bn, l)) {
         return 0;
       }
       l = 0;
@@ -174,10 +174,11 @@ static int decode_dec(BIGNUM *bn, const char *in, int in_len) {
   return 1;
 }
 
-typedef int (*decode_func) (BIGNUM *bn, const char *in, int in_len);
-typedef int (*char_test_func) (int c);
+typedef int (*decode_func)(BIGNUM *bn, const char *in, int in_len);
+typedef int (*char_test_func)(int c);
 
-static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode, char_test_func want_char) {
+static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode,
+                   char_test_func want_char) {
   BIGNUM *ret = NULL;
   int neg = 0, i;
   int num;
@@ -191,7 +192,8 @@ static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode, char_test_
     in++;
   }
 
-  for (i = 0; want_char((unsigned char)in[i]) && i + neg < INT_MAX; i++) {}
+  for (i = 0; want_char((unsigned char)in[i]) && i + neg < INT_MAX; i++) {
+  }
 
   num = i + neg;
   if (outp == NULL) {
@@ -238,7 +240,7 @@ char *BN_bn2dec(const BIGNUM *a) {
   // and fix at the end.
   BIGNUM *copy = NULL;
   CBB cbb;
-  if (!CBB_init(&cbb, 16) ||
+  if (!CBB_init(&cbb, 16) || //
       !CBB_add_u8(&cbb, 0 /* trailing NUL */)) {
     goto err;
   }
@@ -270,7 +272,7 @@ char *BN_bn2dec(const BIGNUM *a) {
     }
   }
 
-  if (BN_is_negative(a) &&
+  if (BN_is_negative(a) && //
       !CBB_add_u8(&cbb, '-')) {
     goto err;
   }
@@ -282,7 +284,7 @@ char *BN_bn2dec(const BIGNUM *a) {
   }
 
   // Reverse the buffer.
-  for (size_t i = 0; i < len/2; i++) {
+  for (size_t i = 0; i < len / 2; i++) {
     uint8_t tmp = data[i];
     data[i] = data[len - 1 - i];
     data[len - 1 - i] = tmp;
@@ -308,7 +310,7 @@ int BN_asc2bn(BIGNUM **outp, const char *in) {
   }
 
   if (in[0] == '0' && (in[1] == 'X' || in[1] == 'x')) {
-    if (!BN_hex2bn(outp, in+2)) {
+    if (!BN_hex2bn(outp, in + 2)) {
       return 0;
     }
   } else {
@@ -377,9 +379,7 @@ size_t BN_bn2mpi(const BIGNUM *in, uint8_t *out) {
   }
 
   const size_t len = bytes + extend;
-  if (len < bytes ||
-      4 + len < len ||
-      (len & 0xffffffff) != len) {
+  if (len < bytes || 4 + len < len || (len & 0xffffffff) != len) {
     // If we cannot represent the number then we emit zero as the interface
     // doesn't allow an error to be signalled.
     if (out) {
@@ -411,9 +411,9 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
     OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
     return NULL;
   }
-  const size_t in_len = ((size_t)in[0] << 24) |
-                        ((size_t)in[1] << 16) |
-                        ((size_t)in[2] << 8) |
+  const size_t in_len = ((size_t)in[0] << 24) | //
+                        ((size_t)in[1] << 16) | //
+                        ((size_t)in[2] << 8) | //
                         ((size_t)in[3]);
   if (in_len != len - 4) {
     OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
@@ -449,7 +449,7 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
 }
 
 int BN_bn2binpad(const BIGNUM *in, uint8_t *out, int len) {
-  if (len < 0 ||
+  if (len < 0 || //
       !BN_bn2bin_padded(out, (size_t)len, in)) {
     return -1;
   }
@@ -457,7 +457,7 @@ int BN_bn2binpad(const BIGNUM *in, uint8_t *out, int len) {
 }
 
 int BN_bn2lebinpad(const BIGNUM *in, uint8_t *out, int len) {
-  if (len < 0 ||
+  if (len < 0 || //
       !BN_bn2le_padded(out, (size_t)len, in)) {
     return -1;
   }

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

@@ -58,13 +58,15 @@
 
 #include <string.h>
 
-#include <openssl/mem.h>
 #include <openssl/err.h>
+#include <openssl/mem.h>
 
 #include "../internal.h"
 
 
-BUF_MEM *BUF_MEM_new(void) { return OPENSSL_zalloc(sizeof(BUF_MEM)); }
+BUF_MEM *BUF_MEM_new(void) {
+  return reinterpret_cast<BUF_MEM *>(OPENSSL_zalloc(sizeof(BUF_MEM)));
+}
 
 void BUF_MEM_free(BUF_MEM *buf) {
   if (buf == NULL) {
@@ -92,7 +94,8 @@ int BUF_MEM_reserve(BUF_MEM *buf, size_t cap) {
     return 0;
   }
 
-  char *new_buf = OPENSSL_realloc(buf->data, alloc_size);
+  char *new_buf =
+      reinterpret_cast<char *>(OPENSSL_realloc(buf->data, alloc_size));
   if (new_buf == NULL) {
     return 0;
   }

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2016, Google Inc.
+/* Copyright 2016 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

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 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

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 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
@@ -18,15 +18,13 @@
 #include <limits.h>
 #include <string.h>
 
-#include <openssl/mem.h>
 #include <openssl/err.h>
+#include <openssl/mem.h>
 
 #include "../internal.h"
 
 
-void CBB_zero(CBB *cbb) {
-  OPENSSL_memset(cbb, 0, sizeof(CBB));
-}
+void CBB_zero(CBB *cbb) { OPENSSL_memset(cbb, 0, sizeof(CBB)); }
 
 static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
   cbb->is_child = 0;
@@ -41,7 +39,7 @@ static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
 int CBB_init(CBB *cbb, size_t initial_capacity) {
   CBB_zero(cbb);
 
-  uint8_t *buf = OPENSSL_malloc(initial_capacity);
+  uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(initial_capacity));
   if (initial_capacity > 0 && buf == NULL) {
     return 0;
   }
@@ -92,7 +90,8 @@ static int cbb_buffer_reserve(struct cbb_buffer_st *base, uint8_t **out,
     if (newcap < base->cap || newcap < newlen) {
       newcap = newlen;
     }
-    uint8_t *newbuf = OPENSSL_realloc(base->buf, newcap);
+    uint8_t *newbuf =
+        reinterpret_cast<uint8_t *>(OPENSSL_realloc(base->buf, newcap));
     if (newbuf == NULL) {
       goto err;
     }
@@ -200,13 +199,13 @@ int CBB_flush(CBB *cbb) {
   assert(child->base == base);
   size_t child_start = child->offset + child->pending_len_len;
 
-  if (!CBB_flush(cbb->child) ||
-      child_start < child->offset ||
+  size_t len;
+  if (!CBB_flush(cbb->child) || child_start < child->offset ||
       base->len < child_start) {
     goto err;
   }
 
-  size_t len = base->len - child_start;
+  len = base->len - child_start;
 
   if (child->pending_is_asn1) {
     // For ASN.1 we assume that we'll only need a single byte for the length.
@@ -215,7 +214,7 @@ int CBB_flush(CBB *cbb) {
     uint8_t len_len;
     uint8_t initial_length_byte;
 
-    assert (child->pending_len_len == 1);
+    assert(child->pending_len_len == 1);
 
     if (len > 0xfffffffe) {
       OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
@@ -403,8 +402,7 @@ int CBB_add_zeros(CBB *cbb, size_t len) {
 }
 
 int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len) {
-  if (!CBB_flush(cbb) ||
-      !cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
+  if (!CBB_flush(cbb) || !cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
     return 0;
   }
   return 1;
@@ -421,9 +419,7 @@ int CBB_reserve(CBB *cbb, uint8_t **out_data, size_t len) {
 int CBB_did_write(CBB *cbb, size_t len) {
   struct cbb_buffer_st *base = cbb_get_base(cbb);
   size_t newlen = base->len + len;
-  if (cbb->child != NULL ||
-      newlen < base->len ||
-      newlen > base->cap) {
+  if (cbb->child != NULL || newlen < base->len || newlen > base->cap) {
     return 0;
   }
   base->len = newlen;
@@ -450,33 +446,23 @@ static int cbb_add_u(CBB *cbb, uint64_t v, size_t len_len) {
   return 1;
 }
 
-int CBB_add_u8(CBB *cbb, uint8_t value) {
-  return cbb_add_u(cbb, value, 1);
-}
+int CBB_add_u8(CBB *cbb, uint8_t value) { return cbb_add_u(cbb, value, 1); }
 
-int CBB_add_u16(CBB *cbb, uint16_t value) {
-  return cbb_add_u(cbb, value, 2);
-}
+int CBB_add_u16(CBB *cbb, uint16_t value) { return cbb_add_u(cbb, value, 2); }
 
 int CBB_add_u16le(CBB *cbb, uint16_t value) {
   return CBB_add_u16(cbb, CRYPTO_bswap2(value));
 }
 
-int CBB_add_u24(CBB *cbb, uint32_t value) {
-  return cbb_add_u(cbb, value, 3);
-}
+int CBB_add_u24(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 3); }
 
-int CBB_add_u32(CBB *cbb, uint32_t value) {
-  return cbb_add_u(cbb, value, 4);
-}
+int CBB_add_u32(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 4); }
 
 int CBB_add_u32le(CBB *cbb, uint32_t value) {
   return CBB_add_u32(cbb, CRYPTO_bswap4(value));
 }
 
-int CBB_add_u64(CBB *cbb, uint64_t value) {
-  return cbb_add_u(cbb, value, 8);
-}
+int CBB_add_u64(CBB *cbb, uint64_t value) { return cbb_add_u(cbb, value, 8); }
 
 int CBB_add_u64le(CBB *cbb, uint64_t value) {
   return CBB_add_u64(cbb, CRYPTO_bswap8(value));
@@ -501,13 +487,13 @@ int CBB_add_asn1_uint64(CBB *cbb, uint64_t value) {
 
 int CBB_add_asn1_uint64_with_tag(CBB *cbb, uint64_t value, CBS_ASN1_TAG tag) {
   CBB child;
+  int started = 0;
   if (!CBB_add_asn1(cbb, &child, tag)) {
     goto err;
   }
 
-  int started = 0;
   for (size_t i = 0; i < 8; i++) {
-    uint8_t byte = (value >> 8*(7-i)) & 0xff;
+    uint8_t byte = (value >> 8 * (7 - i)) & 0xff;
     if (!started) {
       if (byte == 0) {
         // Don't encode leading zeros.
@@ -573,8 +559,7 @@ err:
 int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_OCTETSTRING) ||
-      !CBB_add_bytes(&child, data, data_len) ||
-      !CBB_flush(cbb)) {
+      !CBB_add_bytes(&child, data, data_len) || !CBB_flush(cbb)) {
     cbb_on_error(cbb);
     return 0;
   }
@@ -585,8 +570,7 @@ int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
 int CBB_add_asn1_bool(CBB *cbb, int value) {
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_BOOLEAN) ||
-      !CBB_add_u8(&child, value != 0 ? 0xff : 0) ||
-      !CBB_flush(cbb)) {
+      !CBB_add_u8(&child, value != 0 ? 0xff : 0) || !CBB_flush(cbb)) {
     cbb_on_error(cbb);
     return 0;
   }
@@ -620,24 +604,20 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
 
   // OIDs must have at least two components.
   uint64_t a, b;
-  if (!parse_dotted_decimal(&cbs, &a) ||
-      !parse_dotted_decimal(&cbs, &b)) {
+  if (!parse_dotted_decimal(&cbs, &a) || !parse_dotted_decimal(&cbs, &b)) {
     return 0;
   }
 
   // The first component is encoded as 40 * |a| + |b|. This assumes that |a| is
   // 0, 1, or 2 and that, when it is 0 or 1, |b| is at most 39.
-  if (a > 2 ||
-      (a < 2 && b > 39) ||
-      b > UINT64_MAX - 80 ||
+  if (a > 2 || (a < 2 && b > 39) || b > UINT64_MAX - 80 ||
       !add_base128_integer(cbb, 40u * a + b)) {
     return 0;
   }
 
   // The remaining components are encoded unmodified.
   while (CBS_len(&cbs) > 0) {
-    if (!parse_dotted_decimal(&cbs, &a) ||
-        !add_base128_integer(cbb, a)) {
+    if (!parse_dotted_decimal(&cbs, &a) || !add_base128_integer(cbb, a)) {
       return 0;
     }
   }
@@ -648,7 +628,8 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
 static int compare_set_of_element(const void *a_ptr, const void *b_ptr) {
   // See X.690, section 11.6 for the ordering. They are sorted in ascending
   // order by their DER encoding.
-  const CBS *a = a_ptr, *b = b_ptr;
+  const CBS *a = reinterpret_cast<const CBS *>(a_ptr),
+            *b = reinterpret_cast<const CBS *>(b_ptr);
   size_t a_len = CBS_len(a), b_len = CBS_len(b);
   size_t min_len = a_len < b_len ? a_len : b_len;
   int ret = OPENSSL_memcmp(CBS_data(a), CBS_data(b), min_len);
@@ -687,8 +668,12 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
   // remain valid as we rewrite |cbb|.
   int ret = 0;
   size_t buf_len = CBB_len(cbb);
-  uint8_t *buf = OPENSSL_memdup(CBB_data(cbb), buf_len);
-  CBS *children = OPENSSL_calloc(num_children, sizeof(CBS));
+  uint8_t *buf =
+      reinterpret_cast<uint8_t *>(OPENSSL_memdup(CBB_data(cbb), buf_len));
+  CBS *children =
+      reinterpret_cast<CBS *>(OPENSSL_calloc(num_children, sizeof(CBS)));
+  uint8_t *out;
+  size_t offset = 0;
   if (buf == NULL || children == NULL) {
     goto err;
   }
@@ -701,8 +686,7 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
   qsort(children, num_children, sizeof(CBS), compare_set_of_element);
 
   // Write the contents back in the new order.
-  uint8_t *out = (uint8_t *)CBB_data(cbb);
-  size_t offset = 0;
+  out = (uint8_t *)CBB_data(cbb);
   for (size_t i = 0; i < num_children; i++) {
     OPENSSL_memcpy(out + offset, CBS_data(&children[i]), CBS_len(&children[i]));
     offset += CBS_len(&children[i]);