grpc 1.84.0 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/include/openssl/asn1t.h

@@ -26,8 +26,8 @@ extern "C" {
 /* Legacy ASN.1 library template definitions.
  *
  * This header is used to define new types in OpenSSL's ASN.1 implementation. It
- * is deprecated and will be unexported from the library. Use the new |CBS| and
- * |CBB| library in <openssl/bytestring.h> instead. */
+ * is deprecated and will be unexported from the library. Use the new `CBS` and
+ * `CBB` library in <openssl/bytestring.h> instead. */
 
 
 typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
@@ -290,12 +290,10 @@ struct ASN1_TEMPLATE_st {
 typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
 typedef struct ASN1_ADB_st ASN1_ADB;
 
-typedef struct asn1_must_be_null_st ASN1_MUST_BE_NULL;
-
 struct ASN1_ADB_st {
   uint32_t flags;       /* Various flags */
   unsigned long offset; /* Offset of selector field */
-  ASN1_MUST_BE_NULL *unused;
+  CRYPTO_MUST_BE_NULL *unused;
   const ASN1_ADB_TABLE *tbl;       /* Table of possible types */
   long tblcount;                   /* Number of entries in tbl */
   const ASN1_TEMPLATE *default_tt; /* Type to use if no match */
@@ -455,7 +453,7 @@ typedef struct ASN1_AUX_st {
   uint32_t flags;
   int ref_offset; /* Offset of reference value */
   ASN1_aux_cb *asn1_cb;
-  int enc_offset; /* Offset of ASN1_ENCODING structure */
+  int enc_offset; /* Offset of bssl::ASN1_ENCODING structure */
 } ASN1_AUX;
 
 /* Flags in ASN1_AUX */
@@ -493,8 +491,8 @@ typedef struct ASN1_AUX_st {
   ASN1_ITEM_start(itname) ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, \
       sizeof(ASN1_STRING), #itname ASN1_ITEM_end(itname)
 
-#define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs)                     \
-  ASN1_ITEM_start(sname) ASN1_ITYPE_EXTERN, tag, NULL, 0, &fptrs, 0, \
+#define IMPLEMENT_EXTERN_ASN1(sname, fptrs)                         \
+  ASN1_ITEM_start(sname) ASN1_ITYPE_EXTERN, -1, NULL, 0, &fptrs, 0, \
       #sname ASN1_ITEM_end(sname)
 
 /* Macro to implement standard functions in terms of ASN1_ITEM structures */
@@ -580,7 +578,7 @@ DEFINE_STACK_OF(ASN1_VALUE)
 
 
 #if defined(__cplusplus)
-}  // extern "C"
+}  // extern C
 #endif
 
 #endif  // OPENSSL_HEADER_ASN1T_H

data/third_party/boringssl-with-bazel/include/openssl/base.h

@@ -42,7 +42,7 @@
 #include <openssl/target.h>  // IWYU pragma: export
 
 #if defined(BORINGSSL_PREFIX)
-#include <boringssl_prefix_symbols.h>
+#include <openssl/prefix_symbols.h>  // IWYU pragma: export
 #endif
 
 #if defined(__cplusplus)
@@ -51,7 +51,7 @@ extern "C" {
 
 
 #if defined(__APPLE__)
-// Note |TARGET_OS_MAC| is set for all Apple OS variants. |TARGET_OS_OSX|
+// Note `TARGET_OS_MAC` is set for all Apple OS variants. `TARGET_OS_OSX`
 // targets macOS specifically.
 #if defined(TARGET_OS_OSX) && TARGET_OS_OSX
 #define OPENSSL_MACOS
@@ -73,7 +73,7 @@ extern "C" {
 // A consumer may use this symbol in the preprocessor to temporarily build
 // against multiple revisions of BoringSSL at the same time. It is not
 // recommended to do so for longer than is necessary.
-#define BORINGSSL_API_VERSION 36
+#define BORINGSSL_API_VERSION 42
 
 #if defined(BORINGSSL_SHARED_LIBRARY)
 
@@ -145,6 +145,14 @@ extern "C" {
 #define OPENSSL_PRINTF_FORMAT_FUNC(string_index, first_to_check)
 #endif
 
+// OPENSSL_GNUC_CLANG_PRAGMA emits a pragma on GCC or clang and nothing on other
+// compilers.
+#if defined(__GNUC__) || defined(__clang__)
+#define OPENSSL_GNUC_CLANG_PRAGMA(arg) _Pragma(arg)
+#else
+#define OPENSSL_GNUC_CLANG_PRAGMA(arg)
+#endif
+
 // OPENSSL_CLANG_PRAGMA emits a pragma on clang and nothing on other compilers.
 #if defined(__clang__)
 #define OPENSSL_CLANG_PRAGMA(arg) _Pragma(arg)
@@ -172,33 +180,13 @@ extern "C" {
 #define OPENSSL_UNUSED
 #endif
 
-// C and C++ handle inline functions differently. In C++, an inline function is
-// defined in just the header file, potentially emitted in multiple compilation
-// units (in cases the compiler did not inline), but each copy must be identical
-// to satsify ODR. In C, a non-static inline must be manually emitted in exactly
-// one compilation unit with a separate extern inline declaration.
-//
-// In both languages, exported inline functions referencing file-local symbols
-// are problematic. C forbids this altogether (though GCC and Clang seem not to
-// enforce it). It works in C++, but ODR requires the definitions be identical,
-// including all names in the definitions resolving to the "same entity". In
-// practice, this is unlikely to be a problem, but an inline function that
-// returns a pointer to a file-local symbol
-// could compile oddly.
-//
-// Historically, we used static inline in headers. However, to satisfy ODR, use
-// plain inline in C++, to allow inline consumer functions to call our header
-// functions. Plain inline would also work better with C99 inline, but that is
-// not used much in practice, extern inline is tedious, and there are conflicts
-// with the old gnu89 model:
-// https://stackoverflow.com/questions/216510/extern-inline
-#if defined(__cplusplus)
-#define OPENSSL_INLINE inline
-#else
+#if defined(BORINGSSL_ALWAYS_USE_STATIC_INLINE)
 // Add OPENSSL_UNUSED so that, should an inline function be emitted via macro
-// (e.g. a |STACK_OF(T)| implementation) in a source file without tripping
+// (e.g. a `STACK_OF(T)` implementation) in a source file without tripping
 // clang's -Wunused-function.
 #define OPENSSL_INLINE static inline OPENSSL_UNUSED
+#else
+#define OPENSSL_INLINE inline
 #endif
 
 #if defined(__cplusplus)
@@ -220,25 +208,29 @@ enum ssl_verify_result_t BORINGSSL_ENUM_INT;
 #endif
 
 // ossl_ssize_t is a signed type which is large enough to fit the size of any
-// valid memory allocation. We prefer using |size_t|, but sometimes we need a
+// valid memory allocation. We prefer using `size_t`, but sometimes we need a
 // signed type for OpenSSL API compatibility. This type can be used in such
 // cases to avoid overflow.
 //
-// Not all |size_t| values fit in |ossl_ssize_t|, but all |size_t| values that
+// Not all `size_t` values fit in `ossl_ssize_t`, but all `size_t` values that
 // are sizes of or indices into C objects, can be converted without overflow.
 typedef ptrdiff_t ossl_ssize_t;
 
-// CBS_ASN1_TAG is the type used by |CBS| and |CBB| for ASN.1 tags. See that
+// CBS_ASN1_TAG is the type used by `CBS` and `CBB` for ASN.1 tags. See that
 // header for details. This type is defined in base.h as a forward declaration.
 typedef uint32_t CBS_ASN1_TAG;
 
 // CRYPTO_THREADID is a dummy value.
 typedef int CRYPTO_THREADID;
 
-// An |ASN1_NULL| is an opaque type. asn1.h represents the ASN.1 NULL value as
-// an opaque, non-NULL |ASN1_NULL*| pointer.
+// An `ASN1_NULL` is an opaque type. asn1.h represents the ASN.1 NULL value as
+// an opaque, non-NULL `ASN1_NULL*` pointer.
 typedef struct asn1_null_st ASN1_NULL;
 
+// CRYPTO_MUST_BE_NULL is an opaque type that is never returned from BoringSSL.
+// It is used in function parameters that must be NULL.
+typedef struct crypto_must_be_null_st CRYPTO_MUST_BE_NULL;
+
 typedef int ASN1_BOOLEAN;
 typedef struct ASN1_ITEM_st ASN1_ITEM;
 typedef struct asn1_object_st ASN1_OBJECT;
@@ -297,6 +289,8 @@ typedef struct conf_st CONF;
 typedef struct conf_value_st CONF_VALUE;
 typedef struct crypto_buffer_pool_st CRYPTO_BUFFER_POOL;
 typedef struct crypto_buffer_st CRYPTO_BUFFER;
+typedef struct crypto_ivec_st CRYPTO_IVEC;
+typedef struct crypto_iovec_st CRYPTO_IOVEC;
 typedef struct ctr_drbg_state_st CTR_DRBG_STATE;
 typedef struct dh_st DH;
 typedef struct dsa_st DSA;
@@ -318,12 +312,16 @@ typedef struct evp_hpke_ctx_st EVP_HPKE_CTX;
 typedef struct evp_hpke_kdf_st EVP_HPKE_KDF;
 typedef struct evp_hpke_kem_st EVP_HPKE_KEM;
 typedef struct evp_hpke_key_st EVP_HPKE_KEY;
+typedef struct evp_kem_st EVP_KEM;
+typedef struct evp_pkey_alg_st EVP_PKEY_ALG;
 typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
 typedef struct evp_pkey_st EVP_PKEY;
 typedef struct hmac_ctx_st HMAC_CTX;
 typedef struct md4_state_st MD4_CTX;
 typedef struct md5_state_st MD5_CTX;
 typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
+typedef struct ossl_lib_ctx_st OSSL_LIB_CTX;
+typedef struct ossl_param_st OSSL_PARAM;
 typedef struct pkcs12_st PKCS12;
 typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
 typedef struct private_key_st X509_PKEY;
@@ -367,7 +365,7 @@ typedef struct x509_store_st X509_STORE;
 
 typedef void *OPENSSL_BLOCK;
 
-// BSSL_CHECK aborts if |condition| is not true.
+// BSSL_CHECK aborts if `condition` is not true.
 #define BSSL_CHECK(condition) \
   do {                        \
     if (!(condition)) {       \
@@ -393,27 +391,6 @@ typedef void *OPENSSL_BLOCK;
 #define BSSL_NAMESPACE_END }
 #endif
 
-// MSVC doesn't set __cplusplus to 201103 to indicate C++11 support (see
-// https://connect.microsoft.com/VisualStudio/feedback/details/763051/a-value-of-predefined-macro-cplusplus-is-still-199711l)
-// so MSVC is just assumed to support C++11.
-#if !defined(BORINGSSL_NO_CXX) && __cplusplus < 201103L && !defined(_MSC_VER)
-#define BORINGSSL_NO_CXX
-#endif
-
-#if !defined(BORINGSSL_NO_CXX)
-
-extern "C++" {
-
-#include <memory>
-
-// STLPort, used by some Android consumers, not have std::unique_ptr.
-#if defined(_STLPORT_VERSION)
-#define BORINGSSL_NO_CXX
-#endif
-
-}  // extern C++
-#endif  // !BORINGSSL_NO_CXX
-
 #if defined(BORINGSSL_NO_CXX)
 
 #define BORINGSSL_MAKE_DELETER(type, deleter)
@@ -421,8 +398,11 @@ extern "C++" {
 
 #else
 
+// Work around consumers including our headers under extern "C".
 extern "C++" {
 
+#include <memory>
+
 BSSL_NAMESPACE_BEGIN
 
 namespace internal {

data/third_party/boringssl-with-bazel/include/openssl/base64.h

@@ -33,29 +33,29 @@ extern "C" {
 
 // Encoding
 
-// EVP_EncodeBlock encodes |src_len| bytes from |src| and writes the
-// result to |dst| with a trailing NUL. It returns the number of bytes
+// EVP_EncodeBlock encodes `src_len` bytes from `src` and writes the
+// result to `dst` with a trailing NUL. It returns the number of bytes
 // written, not including this trailing NUL.
 OPENSSL_EXPORT size_t EVP_EncodeBlock(uint8_t *dst, const uint8_t *src,
                                       size_t src_len);
 
-// EVP_EncodedLength sets |*out_len| to the number of bytes that will be needed
-// to call |EVP_EncodeBlock| on an input of length |len|. This includes the
-// final NUL that |EVP_EncodeBlock| writes. It returns one on success or zero
+// EVP_EncodedLength sets `*out_len` to the number of bytes that will be needed
+// to call `EVP_EncodeBlock` on an input of length `len`. This includes the
+// final NUL that `EVP_EncodeBlock` writes. It returns one on success or zero
 // on error.
 OPENSSL_EXPORT int EVP_EncodedLength(size_t *out_len, size_t len);
 
 
 // Decoding
 
-// EVP_DecodedLength sets |*out_len| to the maximum number of bytes that will
-// be needed to call |EVP_DecodeBase64| on an input of length |len|. It returns
-// one on success or zero if |len| is not a valid length for a base64-encoded
+// EVP_DecodedLength sets `*out_len` to the maximum number of bytes that will
+// be needed to call `EVP_DecodeBase64` on an input of length `len`. It returns
+// one on success or zero if `len` is not a valid length for a base64-encoded
 // string.
 OPENSSL_EXPORT int EVP_DecodedLength(size_t *out_len, size_t len);
 
-// EVP_DecodeBase64 decodes |in_len| bytes from base64 and writes
-// |*out_len| bytes to |out|. |max_out| is the size of the output
+// EVP_DecodeBase64 decodes `in_len` bytes from base64 and writes
+// `*out_len` bytes to `out`. `max_out` is the size of the output
 // buffer. If it is not enough for the maximum output size, the
 // operation fails. It returns one on success or zero on error.
 OPENSSL_EXPORT int EVP_DecodeBase64(uint8_t *out, size_t *out_len,
@@ -69,15 +69,15 @@ OPENSSL_EXPORT int EVP_DecodeBase64(uint8_t *out, size_t *out_len,
 // very specific to PEM. It is also very lenient of invalid input. Use of any of
 // these functions is thus deprecated.
 
-// EVP_ENCODE_CTX_new returns a newly-allocated |EVP_ENCODE_CTX| or NULL on
-// error. The caller must release the result with |EVP_ENCODE_CTX_free|  when
+// EVP_ENCODE_CTX_new returns a newly-allocated `EVP_ENCODE_CTX` or NULL on
+// error. The caller must release the result with `EVP_ENCODE_CTX_free`  when
 // done.
 OPENSSL_EXPORT EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void);
 
-// EVP_ENCODE_CTX_free releases memory associated with |ctx|.
+// EVP_ENCODE_CTX_free releases memory associated with `ctx`.
 OPENSSL_EXPORT void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
 
-// EVP_EncodeInit initialises |*ctx|, which is typically stack
+// EVP_EncodeInit initialises `*ctx`, which is typically stack
 // allocated, for an encoding operation.
 //
 // NOTE: The encoding operation breaks its output with newlines every
@@ -85,29 +85,29 @@ OPENSSL_EXPORT void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
 // EVP_EncodeBlock to encode raw base64.
 OPENSSL_EXPORT void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
 
-// EVP_EncodeUpdate encodes |in_len| bytes from |in| and writes an encoded
-// version of them to |out| and sets |*out_len| to the number of bytes written.
-// Some state may be contained in |ctx| so |EVP_EncodeFinal| must be used to
+// EVP_EncodeUpdate encodes `in_len` bytes from `in` and writes an encoded
+// version of them to `out` and sets `*out_len` to the number of bytes written.
+// Some state may be contained in `ctx` so `EVP_EncodeFinal` must be used to
 // flush it before using the encoded data.
 OPENSSL_EXPORT void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, uint8_t *out,
                                      int *out_len, const uint8_t *in,
                                      size_t in_len);
 
-// EVP_EncodeFinal flushes any remaining output bytes from |ctx| to |out| and
-// sets |*out_len| to the number of bytes written.
+// EVP_EncodeFinal flushes any remaining output bytes from `ctx` to `out` and
+// sets `*out_len` to the number of bytes written.
 OPENSSL_EXPORT void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, uint8_t *out,
                                     int *out_len);
 
-// EVP_DecodeInit initialises |*ctx|, which is typically stack allocated, for
+// EVP_DecodeInit initialises `*ctx`, which is typically stack allocated, for
 // a decoding operation.
 //
 // TODO(davidben): This isn't a straight-up base64 decode either. Document
 // and/or fix exactly what's going on here; maximum line length and such.
 OPENSSL_EXPORT void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
 
-// EVP_DecodeUpdate decodes |in_len| bytes from |in| and writes the decoded
-// data to |out| and sets |*out_len| to the number of bytes written. Some state
-// may be contained in |ctx| so |EVP_DecodeFinal| must be used to flush it
+// EVP_DecodeUpdate decodes `in_len` bytes from `in` and writes the decoded
+// data to `out` and sets `*out_len` to the number of bytes written. Some state
+// may be contained in `ctx` so `EVP_DecodeFinal` must be used to flush it
 // before using the encoded data.
 //
 // It returns -1 on error, one if a full line of input was processed and zero
@@ -116,14 +116,14 @@ OPENSSL_EXPORT int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, uint8_t *out,
                                     int *out_len, const uint8_t *in,
                                     size_t in_len);
 
-// EVP_DecodeFinal flushes any remaining output bytes from |ctx| to |out| and
-// sets |*out_len| to the number of bytes written. It returns one on success
+// EVP_DecodeFinal flushes any remaining output bytes from `ctx` to `out` and
+// sets `*out_len` to the number of bytes written. It returns one on success
 // and minus one on error.
 OPENSSL_EXPORT int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, uint8_t *out,
                                    int *out_len);
 
-// EVP_DecodeBlock encodes |src_len| bytes from |src| and writes the result to
-// |dst|. It returns the number of bytes written or -1 on error.
+// EVP_DecodeBlock encodes `src_len` bytes from `src` and writes the result to
+// `dst`. It returns the number of bytes written or -1 on error.
 //
 // WARNING: EVP_DecodeBlock's return value does not take padding into
 // account. It also strips leading whitespace and trailing
@@ -133,9 +133,9 @@ OPENSSL_EXPORT int EVP_DecodeBlock(uint8_t *dst, const uint8_t *src,
 
 
 struct evp_encode_ctx_st {
-  // data_used indicates the number of bytes of |data| that are valid. When
-  // encoding, |data| will be filled and encoded as a lump. When decoding, only
-  // the first four bytes of |data| will be used.
+  // data_used indicates the number of bytes of `data` that are valid. When
+  // encoding, `data` will be filled and encoded as a lump. When decoding, only
+  // the first four bytes of `data` will be used.
   unsigned data_used;
   uint8_t data[48];