grpc 1.69.0 → 1.71.0

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

@@ -1,54 +1,16 @@
-/* ====================================================================
- * Copyright (c) 1998-2003 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 1999-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>
 
@@ -61,6 +23,7 @@
 #include "../internal.h"
 
 
+namespace {
 struct bio_bio_st {
   BIO *peer;  // NULL if buf == NULL.
               // If peer != NULL, then peer->ptr is also a bio_bio_st,
@@ -79,9 +42,11 @@ struct bio_bio_st {
                    // it (unsuccessfully) tried to read,
                    // never more than buffer space (size-len) warrants.
 };
+}  // namespace
 
 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 +57,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 +70,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 +89,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 +114,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 +198,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 +267,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 +279,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 +291,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 +314,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 +356,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 +369,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 +389,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 +415,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.cc

@@ -0,0 +1,59 @@
+// 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>
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <openssl/err.h>
+#include <openssl/mem.h>
+
+int BIO_printf(BIO *bio, const char *format, ...) {
+  va_list args;
+  char buf[256], *out, out_malloced = 0;
+  int out_len, ret;
+
+  va_start(args, format);
+  out_len = vsnprintf(buf, sizeof(buf), format, args);
+  va_end(args);
+  if (out_len < 0) {
+    return -1;
+  }
+
+  if ((size_t)out_len >= sizeof(buf)) {
+    const size_t requested_len = (size_t)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 = reinterpret_cast<char *>(OPENSSL_malloc(requested_len + 1));
+    out_malloced = 1;
+    if (out == NULL) {
+      return -1;
+    }
+    va_start(args, format);
+    out_len = vsnprintf(out, requested_len + 1, format, args);
+    va_end(args);
+    assert(out_len == (int)requested_len);
+  } else {
+    out = buf;
+  }
+
+  ret = BIO_write(bio, out, out_len);
+  if (out_malloced) {
+    OPENSSL_free(out);
+  }
+
+  return ret;
+}

data/third_party/boringssl-with-bazel/src/crypto/bio/socket.cc

@@ -0,0 +1,147 @@
+// 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>
+
+#if !defined(OPENSSL_NO_SOCK)
+
+#include <fcntl.h>
+#include <string.h>
+
+#if !defined(OPENSSL_WINDOWS)
+#include <unistd.h>
+#else
+OPENSSL_MSVC_PRAGMA(warning(push, 3))
+#include <winsock2.h>
+OPENSSL_MSVC_PRAGMA(warning(pop))
+
+OPENSSL_MSVC_PRAGMA(comment(lib, "Ws2_32.lib"))
+#endif
+
+#include "internal.h"
+
+
+#if !defined(OPENSSL_WINDOWS)
+static int closesocket(int sock) {
+  return close(sock);
+}
+#endif
+
+static int sock_free(BIO *bio) {
+  if (bio->shutdown) {
+    if (bio->init) {
+      closesocket(bio->num);
+    }
+    bio->init = 0;
+    bio->flags = 0;
+  }
+  return 1;
+}
+
+static int sock_read(BIO *b, char *out, int outl) {
+  if (out == NULL) {
+    return 0;
+  }
+
+  bio_clear_socket_error();
+#if defined(OPENSSL_WINDOWS)
+  int ret = recv(b->num, out, outl, 0);
+#else
+  int ret = (int)read(b->num, out, outl);
+#endif
+  BIO_clear_retry_flags(b);
+  if (ret <= 0) {
+    if (bio_socket_should_retry(ret)) {
+      BIO_set_retry_read(b);
+    }
+  }
+  return ret;
+}
+
+static int sock_write(BIO *b, const char *in, int inl) {
+  bio_clear_socket_error();
+#if defined(OPENSSL_WINDOWS)
+  int ret = send(b->num, in, inl, 0);
+#else
+  int ret = (int)write(b->num, in, inl);
+#endif
+  BIO_clear_retry_flags(b);
+  if (ret <= 0) {
+    if (bio_socket_should_retry(ret)) {
+      BIO_set_retry_write(b);
+    }
+  }
+  return ret;
+}
+
+static long sock_ctrl(BIO *b, int cmd, long num, void *ptr) {
+  long ret = 1;
+  int *ip;
+
+  switch (cmd) {
+    case BIO_C_SET_FD:
+      sock_free(b);
+      b->num = *((int *)ptr);
+      b->shutdown = (int)num;
+      b->init = 1;
+      break;
+    case BIO_C_GET_FD:
+      if (b->init) {
+        ip = (int *)ptr;
+        if (ip != NULL) {
+          *ip = b->num;
+        }
+        ret = b->num;
+      } else {
+        ret = -1;
+      }
+      break;
+    case BIO_CTRL_GET_CLOSE:
+      ret = b->shutdown;
+      break;
+    case BIO_CTRL_SET_CLOSE:
+      b->shutdown = (int)num;
+      break;
+    case BIO_CTRL_FLUSH:
+      ret = 1;
+      break;
+    default:
+      ret = 0;
+      break;
+  }
+  return ret;
+}
+
+static const BIO_METHOD methods_sockp = {
+    BIO_TYPE_SOCKET, "socket",
+    sock_write,      sock_read,
+    NULL /* puts */, NULL /* gets, */,
+    sock_ctrl,       NULL /* create */,
+    sock_free,       NULL /* callback_ctrl */,
+};
+
+const BIO_METHOD *BIO_s_socket(void) { return &methods_sockp; }
+
+BIO *BIO_new_socket(int fd, int close_flag) {
+  BIO *ret;
+
+  ret = BIO_new(BIO_s_socket());
+  if (ret == NULL) {
+    return NULL;
+  }
+  BIO_set_fd(ret, fd, close_flag);
+  return ret;
+}
+
+#endif  // OPENSSL_NO_SOCK

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

@@ -1,16 +1,16 @@
-/* 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.
 
 #if defined(__linux__)
 #undef _POSIX_C_SOURCE

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

@@ -1,16 +1,16 @@
-/* Copyright (c) 2021, 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 2021 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/blake2.h>
 
@@ -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/bn_asn1.cc}

@@ -1,16 +1,16 @@
-/* Copyright (c) 2015, 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 2015 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/bn.h>