grpc 1.54.2 → 1.55.3

data/src/core/lib/surface/validate_metadata.h

@@ -25,7 +25,6 @@
 
 #include <cstring>
 
-#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
@@ -35,9 +34,20 @@
 
 namespace grpc_core {
 
-absl::Status ValidateHeaderKeyIsLegal(absl::string_view key);
+enum class ValidateMetadataResult : uint8_t {
+  kOk,
+  kCannotBeZeroLength,
+  kTooLong,
+  kIllegalHeaderKey,
+  kIllegalHeaderValue
+};
 
-}
+const char* ValidateMetadataResultToString(ValidateMetadataResult result);
+
+// Returns nullopt if the key is legal, otherwise returns an error message.
+ValidateMetadataResult ValidateHeaderKeyIsLegal(absl::string_view key);
+
+}  // namespace grpc_core
 
 grpc_error_handle grpc_validate_header_key_is_legal(const grpc_slice& slice);
 grpc_error_handle grpc_validate_header_nonbin_value_is_legal(

data/src/core/lib/surface/version.cc

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "31.0.0"; }
+const char* grpc_version_string(void) { return "32.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gracious"; }
+const char* grpc_g_stands_for(void) { return "grandslam"; }

data/src/core/lib/transport/batch_builder.h

@@ -154,6 +154,7 @@ class BatchBuilder {
 
     absl::optional<SliceBuffer> payload;
     uint32_t flags;
+    bool call_failed_before_recv_message = false;
   };
 
   // A pending receive metadata.
@@ -392,12 +393,19 @@ inline auto BatchBuilder::ReceiveMessage(Target target) {
   payload_->recv_message.recv_message_ready = &pc->on_done_closure;
   payload_->recv_message.recv_message = &pc->payload;
   payload_->recv_message.flags = &pc->flags;
+  payload_->recv_message.call_failed_before_recv_message =
+      &pc->call_failed_before_recv_message;
   return batch->RefUntil(
       Map(pc->done_latch.Wait(),
           [pc](absl::Status status)
               -> absl::StatusOr<absl::optional<MessageHandle>> {
             if (!status.ok()) return status;
-            if (!pc->payload.has_value()) return absl::nullopt;
+            if (!pc->payload.has_value()) {
+              if (pc->call_failed_before_recv_message) {
+                return absl::CancelledError();
+              }
+              return absl::nullopt;
+            }
             return pc->IntoMessageHandle();
           }));
 }

data/src/core/lib/transport/metadata_batch.h

@@ -46,51 +46,12 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/custom_metadata.h"
+#include "src/core/lib/transport/metadata_compression_traits.h"
 #include "src/core/lib/transport/parsed_metadata.h"
+#include "src/core/lib/transport/simple_slice_based_metadata.h"
 
 namespace grpc_core {
 
-///////////////////////////////////////////////////////////////////////////////
-// Compression traits.
-//
-// Each metadata trait exposes exactly one compression trait.
-// This type directs how transports might choose to compress the metadata.
-// Adding a value here typically involves editing all transports to support the
-// trait, and so should not be done lightly.
-
-// No compression.
-struct NoCompressionCompressor {};
-
-// Expect a single value for this metadata key, but we don't know apriori its
-// value.
-// It's ok if it changes over time, but it should be mostly stable.
-// This is used for things like user-agent, which is expected to be the same
-// for all requests.
-struct StableValueCompressor {};
-
-// Expect a single value for this metadata key, and we know apriori its value.
-template <typename T, T value>
-struct KnownValueCompressor {};
-
-// Values are uncompressible, but expect the key to be in most requests and try
-// and compress that.
-struct FrequentKeyWithNoValueCompressionCompressor {};
-
-// Expect a small set of values for this metadata key.
-struct SmallSetOfValuesCompressor {};
-
-// Expect integral values up to N for this metadata key.
-template <size_t N>
-struct SmallIntegralValuesCompressor {};
-
-// Specialty compressor for grpc-timeout metadata.
-struct TimeoutCompressor {};
-
-// Specialty compressors for HTTP/2 psuedo headers.
-struct HttpSchemeCompressor {};
-struct HttpMethodCompressor {};
-struct HttpStatusCompressor {};
-
 ///////////////////////////////////////////////////////////////////////////////
 // Metadata traits
 
@@ -282,22 +243,6 @@ struct GrpcAcceptEncodingMetadata {
   }
 };
 
-struct SimpleSliceBasedMetadata {
-  using ValueType = Slice;
-  using MementoType = Slice;
-  static MementoType ParseMemento(Slice value, MetadataParseErrorFn) {
-    return value.TakeOwned();
-  }
-  static ValueType MementoToValue(MementoType value) { return value; }
-  static Slice Encode(const ValueType& x) { return x.Ref(); }
-  static absl::string_view DisplayValue(const ValueType& value) {
-    return value.as_string_view();
-  }
-  static absl::string_view DisplayMemento(const MementoType& value) {
-    return value.as_string_view();
-  }
-};
-
 // user-agent metadata trait.
 struct UserAgentMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
@@ -1378,8 +1323,6 @@ class MetadataMap {
 
   // Parse metadata from a key/value pair, and return an object representing
   // that result.
-  // TODO(ctiller): key should probably be an absl::string_view.
-  // Once we don't care about interning anymore, make that change!
   static ParsedMetadata<Derived> Parse(absl::string_view key, Slice value,
                                        uint32_t transport_size,
                                        MetadataParseErrorFn on_error) {

data/src/core/lib/transport/metadata_compression_traits.h

@@ -0,0 +1,67 @@
+// Copyright 2023 gRPC 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
+//
+//     http://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 GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_COMPRESSION_TRAITS_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_COMPRESSION_TRAITS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+namespace grpc_core {
+
+///////////////////////////////////////////////////////////////////////////////
+// Compression traits.
+//
+// Each metadata trait exposes exactly one compression trait.
+// This type directs how transports might choose to compress the metadata.
+// Adding a value here typically involves editing all transports to support the
+// trait, and so should not be done lightly.
+
+// No compression.
+struct NoCompressionCompressor {};
+
+// Expect a single value for this metadata key, but we don't know apriori its
+// value.
+// It's ok if it changes over time, but it should be mostly stable.
+// This is used for things like user-agent, which is expected to be the same
+// for all requests.
+struct StableValueCompressor {};
+
+// Expect a single value for this metadata key, and we know apriori its value.
+template <typename T, T value>
+struct KnownValueCompressor {};
+
+// Values are uncompressible, but expect the key to be in most requests and try
+// and compress that.
+struct FrequentKeyWithNoValueCompressionCompressor {};
+
+// Expect a small set of values for this metadata key.
+struct SmallSetOfValuesCompressor {};
+
+// Expect integral values up to N for this metadata key.
+template <size_t N>
+struct SmallIntegralValuesCompressor {};
+
+// Specialty compressor for grpc-timeout metadata.
+struct TimeoutCompressor {};
+
+// Specialty compressors for HTTP/2 psuedo headers.
+struct HttpSchemeCompressor {};
+struct HttpMethodCompressor {};
+struct HttpStatusCompressor {};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_COMPRESSION_TRAITS_H

data/src/core/lib/transport/simple_slice_based_metadata.h

@@ -0,0 +1,48 @@
+// Copyright 2023 gRPC 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
+//
+//     http://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 GRPC_SRC_CORE_LIB_TRANSPORT_SIMPLE_SLICE_BASED_METADATA_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_SIMPLE_SLICE_BASED_METADATA_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/parsed_metadata.h"
+
+namespace grpc_core {
+
+// Models grpc metadata (as per the rules for MetadataMap) for a metadata
+// element that consists of a Slice.
+// Use by deriving from this class and adding `kRepeatable` and `key()`.
+struct SimpleSliceBasedMetadata {
+  using ValueType = Slice;
+  using MementoType = Slice;
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn) {
+    return value.TakeOwned();
+  }
+  static ValueType MementoToValue(MementoType value) { return value; }
+  static Slice Encode(const ValueType& x) { return x.Ref(); }
+  static absl::string_view DisplayValue(const ValueType& value) {
+    return value.as_string_view();
+  }
+  static absl::string_view DisplayMemento(const MementoType& value) {
+    return value.as_string_view();
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_SIMPLE_SLICE_BASED_METADATA_H

data/src/core/lib/transport/transport.h

@@ -211,6 +211,9 @@ struct CallArgs {
   // This should be moved around and only destroyed when the transport is
   // satisfied that the metadata has passed any flow control measures it has.
   ClientInitialMetadataOutstandingToken client_initial_metadata_outstanding;
+  // Latch that will ultimately contain the polling entity for the call.
+  // TODO(ctiller): remove once event engine lands
+  Latch<grpc_polling_entity>* polling_entity;
   // Initial metadata from the server to the client.
   // Set once when it's available.
   // During promise setup filters can substitute their own latch for this

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -50,9 +50,8 @@ extern void RegisterServiceConfigChannelArgFilter(
 extern void RegisterExtraFilters(CoreConfiguration::Builder* builder);
 extern void RegisterResourceQuota(CoreConfiguration::Builder* builder);
 extern void FaultInjectionFilterRegister(CoreConfiguration::Builder* builder);
+extern void RegisterDnsResolver(CoreConfiguration::Builder* builder);
 extern void RegisterBackendMetricFilter(CoreConfiguration::Builder* builder);
-extern void RegisterNativeDnsResolver(CoreConfiguration::Builder* builder);
-extern void RegisterAresDnsResolver(CoreConfiguration::Builder* builder);
 extern void RegisterSockaddrResolver(CoreConfiguration::Builder* builder);
 extern void RegisterFakeResolver(CoreConfiguration::Builder* builder);
 extern void RegisterPriorityLbPolicy(CoreConfiguration::Builder* builder);
@@ -98,8 +97,7 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterServiceConfigChannelArgFilter(builder);
   RegisterResourceQuota(builder);
   FaultInjectionFilterRegister(builder);
-  RegisterAresDnsResolver(builder);
-  RegisterNativeDnsResolver(builder);
+  RegisterDnsResolver(builder);
   RegisterSockaddrResolver(builder);
   RegisterFakeResolver(builder);
   RegisterHttpProxyMapper(builder);

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.54.2'
+  VERSION = '1.55.3'
 end

data/third_party/abseil-cpp/absl/base/config.h

@@ -112,7 +112,7 @@
 // LTS releases can be obtained from
 // https://github.com/abseil/abseil-cpp/releases.
 #define ABSL_LTS_RELEASE_VERSION 20230125
-#define ABSL_LTS_RELEASE_PATCH_LEVEL 2
+#define ABSL_LTS_RELEASE_PATCH_LEVEL 3
 
 // Helper macro to convert a CPP variable to a string literal.
 #define ABSL_INTERNAL_DO_TOKEN_STR(x) #x

data/third_party/boringssl-with-bazel/src/crypto/bio/bio_mem.c

@@ -130,13 +130,15 @@ static int mem_free(BIO *bio) {
 }
 
 static int mem_read(BIO *bio, char *out, int outl) {
-  int ret;
-  BUF_MEM *b = (BUF_MEM*) bio->ptr;
-
   BIO_clear_retry_flags(bio);
-  ret = outl;
-  if (b->length < INT_MAX && ret > (int)b->length) {
-    ret = b->length;
+  if (outl <= 0) {
+    return 0;
+  }
+
+  BUF_MEM *b = bio->ptr;
+  int ret = outl;
+  if ((size_t)ret > b->length) {
+    ret = (int)b->length;
   }
 
   if (ret > 0) {
@@ -157,65 +159,49 @@ static int mem_read(BIO *bio, char *out, int outl) {
 }
 
 static int mem_write(BIO *bio, const char *in, int inl) {
-  int ret = -1;
-  int blen;
-  BUF_MEM *b;
-
-  b = (BUF_MEM *)bio->ptr;
+  BIO_clear_retry_flags(bio);
+  if (inl <= 0) {
+    return 0;  // Successfully write zero bytes.
+  }
 
   if (bio->flags & BIO_FLAGS_MEM_RDONLY) {
     OPENSSL_PUT_ERROR(BIO, BIO_R_WRITE_TO_READ_ONLY_BIO);
-    goto err;
+    return -1;
   }
 
-  BIO_clear_retry_flags(bio);
-  blen = b->length;
-  if (INT_MAX - blen < inl) {
-    goto err;
+  BUF_MEM *b = bio->ptr;
+  if (!BUF_MEM_append(b, in, inl)) {
+    return -1;
   }
-  if (BUF_MEM_grow_clean(b, blen + inl) != ((size_t) blen) + inl) {
-    goto err;
-  }
-  OPENSSL_memcpy(&b->data[blen], in, inl);
-  ret = inl;
 
-err:
-  return ret;
+  return inl;
 }
 
 static int mem_gets(BIO *bio, char *buf, int size) {
-  int i, j;
-  char *p;
-  BUF_MEM *b = (BUF_MEM *)bio->ptr;
-
   BIO_clear_retry_flags(bio);
-  j = b->length;
-  if (size - 1 < j) {
-    j = size - 1;
-  }
-  if (j <= 0) {
-    if (size > 0) {
-      *buf = 0;
-    }
+  if (size <= 0) {
     return 0;
   }
 
-  p = b->data;
-  for (i = 0; i < j; i++) {
-    if (p[i] == '\n') {
-      i++;
-      break;
-    }
+  // The buffer size includes space for the trailing NUL, so we can read at most
+  // one fewer byte.
+  BUF_MEM *b = bio->ptr;
+  int ret = size - 1;
+  if ((size_t)ret > b->length) {
+    ret = (int)b->length;
   }
 
-  // i is now the max num of bytes to copy, either j or up to and including the
-  // first newline
+  // Stop at the first newline.
+  const char *newline = OPENSSL_memchr(b->data, '\n', ret);
+  if (newline != NULL) {
+    ret = (int)(newline - b->data + 1);
+  }
 
-  i = mem_read(bio, buf, i);
-  if (i > 0) {
-    buf[i] = '\0';
+  ret = mem_read(bio, buf, ret);
+  if (ret >= 0) {
+    buf[ret] = '\0';
   }
-  return i;
+  return ret;
 }
 
 static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {

data/third_party/boringssl-with-bazel/src/crypto/bio/fd.c

@@ -241,15 +241,18 @@ static long fd_ctrl(BIO *b, int cmd, long num, void *ptr) {
 }
 
 static int fd_gets(BIO *bp, char *buf, int size) {
-  char *ptr = buf;
-  char *end = buf + size - 1;
-
   if (size <= 0) {
     return 0;
   }
 
-  while (ptr < end && fd_read(bp, ptr, 1) > 0 && ptr[0] != '\n') {
+  char *ptr = buf;
+  char *end = buf + size - 1;
+  while (ptr < end && fd_read(bp, ptr, 1) > 0) {
+    char c = ptr[0];
     ptr++;
+    if (c == '\n') {
+      break;
+    }
   }
 
   ptr[0] = '\0';

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

@@ -16,12 +16,22 @@
 #define OPENSSL_HEADER_CRYPTO_KYBER_INTERNAL_H
 
 #include <openssl/base.h>
+#include <openssl/kyber.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
 
+// KYBER_ENCAP_ENTROPY is the number of bytes of uniformly random entropy
+// necessary to encapsulate a secret. The entropy will be leaked to the
+// decapsulating party.
+#define KYBER_ENCAP_ENTROPY 32
+
+// KYBER_GENERATE_KEY_ENTROPY is the number of bytes of uniformly random entropy
+// necessary to generate a key.
+#define KYBER_GENERATE_KEY_ENTROPY 64
+
 struct BORINGSSL_keccak_st {
   uint64_t state[25];
   size_t rate_bytes;
@@ -50,9 +60,29 @@ OPENSSL_EXPORT void BORINGSSL_keccak_init(
     enum boringssl_keccak_config_t config);
 
 // BORINGSSL_keccak_squeeze writes |out_len| bytes to |out| from |ctx|.
-OPENSSL_EXPORT void BORINGSSL_keccak_squeeze(
-    struct BORINGSSL_keccak_st *ctx, uint8_t *out, size_t out_len);
+OPENSSL_EXPORT void BORINGSSL_keccak_squeeze(struct BORINGSSL_keccak_st *ctx,
+                                             uint8_t *out, size_t out_len);
+
+// KYBER_generate_key_external_entropy is a deterministic function to create a
+// pair of Kyber768 keys, using the supplied entropy. The entropy needs to be
+// uniformly random generated. This function is should only be used for tests,
+// regular callers should use the non-deterministic |KYBER_generate_key|
+// directly.
+OPENSSL_EXPORT void KYBER_generate_key_external_entropy(
+    uint8_t out_encoded_public_key[KYBER_PUBLIC_KEY_BYTES],
+    struct KYBER_private_key *out_private_key,
+    const uint8_t entropy[KYBER_GENERATE_KEY_ENTROPY]);
 
+// KYBER_encap_external_entropy is a deterministic function to encapsulate
+// |out_shared_secret_len| bytes of |out_shared_secret| to |ciphertext|, using
+// |KYBER_ENCAP_ENTROPY| bytes of |entropy| for randomization. The
+// decapsulating side will be able to recover |entropy| in full. This
+// function is should only be used for tests, regular callers should use the
+// non-deterministic |KYBER_encap| directly.
+OPENSSL_EXPORT void KYBER_encap_external_entropy(
+    uint8_t out_ciphertext[KYBER_CIPHERTEXT_BYTES], uint8_t *out_shared_secret,
+    size_t out_shared_secret_len, const struct KYBER_public_key *public_key,
+    const uint8_t entropy[KYBER_ENCAP_ENTROPY]);
 
 #if defined(__cplusplus)
 }

data/third_party/boringssl-with-bazel/src/crypto/kyber/keccak.c

@@ -56,19 +56,18 @@ static void keccak_f(uint64_t state[25]) {
     // and the sequence will repeat. All that remains is to handle the element
     // at (0, 0), but the rotation for that element is zero, and it goes to (0,
     // 0), so we can ignore it.
-    int pi_x = 1, pi_y = 0;
+    static const uint8_t kIndexes[24] = {10, 7,  11, 17, 18, 3,  5,  16,
+                                         8,  21, 24, 4,  15, 23, 19, 13,
+                                         12, 2,  20, 14, 22, 9,  6,  1};
+    static const uint8_t kRotations[24] = {1,  3,  6,  10, 15, 21, 28, 36,
+                                           45, 55, 2,  14, 27, 41, 56, 8,
+                                           25, 43, 62, 18, 39, 61, 20, 44};
     uint64_t prev_value = state[1];
-    int pi_rot = 1;
-    for (int i = 1; i < 25; i++) {
-      const int out_x = pi_y;
-      const int out_y = (2 * pi_x + 3 * pi_y) % 5;
-      const int index = out_y * 5 + out_x;
-      const uint64_t t = state[index];
-      state[index] = CRYPTO_rotl_u64(prev_value, pi_rot);
-      pi_rot = (pi_rot + i + 1) % 64;
-      prev_value = t;
-      pi_x = out_x;
-      pi_y = out_y;
+    for (int i = 0; i < 24; i++) {
+      const uint64_t value = CRYPTO_rotl_u64(prev_value, kRotations[i]);
+      const size_t index = kIndexes[i];
+      prev_value = state[index];
+      state[index] = value;
     }
 
     // χ step