grpc 1.81.1 → 1.82.0.pre2

data/src/core/telemetry/histogram.h

@@ -18,12 +18,10 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <optional>
 #include <vector>
 
 #include "src/core/util/grpc_check.h"
 #include "absl/log/log.h"
-#include "absl/strings/str_join.h"
 #include "absl/types/span.h"
 
 namespace grpc_core {
@@ -72,22 +70,21 @@ class LinearHistogramShape {
 
 class ExponentialHistogramShape {
  public:
-  ExponentialHistogramShape(int64_t max, size_t buckets)
-      : max_(max), buckets_(buckets) {
-    first_non_trivial_ = -1;
+  ExponentialHistogramShape(int64_t max, size_t buckets) {
     GRPC_CHECK_GT(max, 0);
-    GRPC_CHECK_LT(buckets, 1000000000u);
+    // Increase if needed. As of June 2026, the maximum we are using is 100.
+    // Note that the BucketFor has to do a binary search, so it's better to
+    // keep the number of buckets small.
+    GRPC_CHECK_LE(buckets, 512u);
     if (max <= static_cast<int64_t>(buckets)) {
       for (size_t i = 0; i < static_cast<size_t>(max); ++i) {
         bounds_.push_back(i + 1);
       }
-      first_non_trivial_ = max;
-      buckets_ = max;
+      buckets = max;
       return;
     }
-    int64_t first_bucket = std::ceil(std::pow(max, 1.0 / (buckets_ + 1)));
+    int64_t first_bucket = std::ceil(std::pow(max, 1.0 / (buckets + 1)));
     if (first_bucket <= 1) first_bucket = 1;
-    if (first_bucket != 1) first_non_trivial_ = 0;
     bounds_.push_back(first_bucket);
     while (bounds_.size() < buckets) {
       int64_t nextb;
@@ -101,38 +98,10 @@ class ExponentialHistogramShape {
       }
       if (nextb <= bounds_.back() + 1) {
         nextb = bounds_.back() + 1;
-      } else if (first_non_trivial_ == -1) {
-        first_non_trivial_ = bounds_.size();
       }
       bounds_.push_back(nextb);
     }
-    GRPC_CHECK_EQ(bounds_.size(), buckets_);
-    if (first_non_trivial_ == -1) {
-      first_non_trivial_ = max_;
-      offset_ = 0;
-      shift_ = 0;
-      return;
-    }
-    offset_ = DoubleToUint(first_non_trivial_);
-    for (shift_ = 63; shift_ > 0; --shift_) {
-      bool found_alias = false;
-      for (size_t i = first_non_trivial_ + 1; i < bounds_.size(); ++i) {
-        if ((DoubleToUint(bounds_[i]) - offset_) >> shift_ ==
-            (DoubleToUint(bounds_[i - 1]) - offset_) >> shift_) {
-          found_alias = true;
-          break;
-        }
-      }
-      if (!found_alias) {
-        break;
-      }
-    }
-    GRPC_CHECK_GE(shift_, 0u);
-    GRPC_CHECK_LT(shift_, 64u);
-    for (size_t i = 0; i <= (DoubleToUint(max_) - offset_) >> shift_; ++i) {
-      lookup_table_.push_back(
-          BucketInBoundsFor(bounds_, UintToDouble((i << shift_) + offset_)));
-    }
+    GRPC_CHECK_EQ(bounds_.size(), buckets);
   }
 
   ExponentialHistogramShape(const ExponentialHistogramShape&) = delete;
@@ -141,63 +110,15 @@ class ExponentialHistogramShape {
   ExponentialHistogramShape(ExponentialHistogramShape&&) = default;
   ExponentialHistogramShape& operator=(ExponentialHistogramShape&&) = default;
 
-  size_t buckets() const { return buckets_; }
+  size_t buckets() const { return bounds_.size(); }
   size_t BucketFor(int64_t value) const {
-    if (value >= max_) return buckets_ - 1;
-    if (value < first_non_trivial_) {
-      if (value < 0) return 0;
-      return value;
-    }
-    auto index = (DoubleToUint(value) - offset_) >> shift_;
-    size_t bucket = lookup_table_[index];
-    GRPC_DCHECK_LT(bucket, buckets_) << absl::StrJoin(lookup_table_, ",");
-    GRPC_DCHECK_LT(bucket, bounds_.size()) << absl::StrJoin(bounds_, ",");
-    while (bucket < bounds_.size() - 1 && value >= bounds_[bucket]) {
-      ++bucket;
-    }
-    while (bucket > 0 && value < bounds_[bucket - 1]) {
-      --bucket;
-    }
-    GRPC_DCHECK_LT(value, bounds_[bucket]);
-    return bucket;
+    return BucketInBoundsFor(bounds_, value);
   }
 
   HistogramBuckets bounds() const { return bounds_; }
-  absl::Span<const size_t> lookup_table() const { return lookup_table_; }
 
  private:
-  union DblUint {
-    double dbl;
-    uint64_t uint;
-  };
-
-  static double UintToDouble(uint64_t x) {
-    union DblUint {
-      double dbl;
-      uint64_t uint;
-    };
-    DblUint val;
-    val.uint = x;
-    return val.dbl;
-  }
-
-  static uint64_t DoubleToUint(double x) {
-    union DblUint {
-      double dbl;
-      uint64_t uint;
-    };
-    DblUint val;
-    val.dbl = x;
-    return val.uint;
-  }
-
-  int64_t max_;
-  int64_t first_non_trivial_;
-  uint64_t offset_;
-  uint64_t shift_;
-  std::vector<size_t> lookup_table_;
   std::vector<int64_t> bounds_;
-  size_t buckets_;
 };
 
 }  // namespace grpc_core

data/src/core/telemetry/instrument.h

@@ -742,27 +742,31 @@ struct Counter {
 
 // An InstrumentHandle is a handle to a single metric in an
 // instrument domain. It has a Shape (how the metric behaves).
-template <typename Shape, typename Domain>
+template <typename Shape, typename DomainTag>
 class InstrumentHandle {
  public:
+  constexpr InstrumentHandle() = default;
+
+  constexpr InstrumentHandle(
+      instrument_detail::QueryableDomain* instrument_domain,
+      const InstrumentMetadata::Description* description, Shape shape)
+      : instrument_domain_(instrument_domain),
+        offset_(description ? description->offset : 0),
+        shape_(std::move(shape)),
+        description_(description) {}
+
   absl::string_view name() const { return description_->name; }
   absl::string_view description() const { return description_->description; }
   absl::string_view unit() const { return description_->unit; }
   uint64_t offset() const { return offset_; }
 
  private:
-  friend Domain;
-
-  InstrumentHandle(Domain* instrument_domain,
-                   const InstrumentMetadata::Description* description,
-                   Shape shape)
-      : instrument_domain_(instrument_domain),
-        offset_(description->offset),
-        shape_(std::move(shape)),
-        description_(description) {}
+  friend class instrument_detail::QueryableDomain;
+  template <typename B, size_t N, typename T>
+  friend class instrument_detail::InstrumentDomainImpl;
 
-  Domain* instrument_domain_;
-  uint64_t offset_;
+  instrument_detail::QueryableDomain* instrument_domain_ = nullptr;
+  uint64_t offset_ = 0;
   GPR_NO_UNIQUE_ADDRESS Shape shape_;
   const InstrumentMetadata::Description* description_ = nullptr;
 };
@@ -917,34 +921,27 @@ template <typename Backend, size_t N, typename Tag>
 class InstrumentDomainImpl final : public QueryableDomain {
  public:
   using Self = InstrumentDomainImpl<Backend, N, Tag>;
-  using CounterHandle = InstrumentHandle<Counter, Self>;
+  using CounterHandle = InstrumentHandle<Counter, Tag>;
   using UpDownCounterHandle =
-      InstrumentHandle<InstrumentMetadata::UpDownCounterShape, Self>;
+      InstrumentHandle<InstrumentMetadata::UpDownCounterShape, Tag>;
   using DoubleGaugeHandle =
-      InstrumentHandle<InstrumentMetadata::DoubleGaugeShape, Self>;
+      InstrumentHandle<InstrumentMetadata::DoubleGaugeShape, Tag>;
   using IntGaugeHandle =
-      InstrumentHandle<InstrumentMetadata::IntGaugeShape, Self>;
+      InstrumentHandle<InstrumentMetadata::IntGaugeShape, Tag>;
   using UintGaugeHandle =
-      InstrumentHandle<InstrumentMetadata::UintGaugeShape, Self>;
+      InstrumentHandle<InstrumentMetadata::UintGaugeShape, Tag>;
   template <typename Shape>
-  using HistogramHandle = InstrumentHandle<const Shape*, Self>;
+  using HistogramHandle = InstrumentHandle<const Shape*, Tag>;
 
   class GaugeSink {
    public:
     explicit GaugeSink(GaugeStorage& storage) : storage_(storage) {}
 
-    void Set(InstrumentHandle<InstrumentMetadata::DoubleGaugeShape, Self> g,
-             double x) {
+    void Set(DoubleGaugeHandle g, double x) {
       storage_.SetDouble(g.offset_, x);
     }
-    void Set(InstrumentHandle<InstrumentMetadata::IntGaugeShape, Self> g,
-             int64_t x) {
-      storage_.SetInt(g.offset_, x);
-    }
-    void Set(InstrumentHandle<InstrumentMetadata::UintGaugeShape, Self> g,
-             uint64_t x) {
-      storage_.SetUint(g.offset_, x);
-    }
+    void Set(IntGaugeHandle g, int64_t x) { storage_.SetInt(g.offset_, x); }
+    void Set(UintGaugeHandle g, uint64_t x) { storage_.SetUint(g.offset_, x); }
 
    private:
     GaugeStorage& storage_;
@@ -1139,6 +1136,23 @@ class InstrumentDomainImpl final : public QueryableDomain {
 template <class Derived>
 class InstrumentDomain {
  public:
+  using CounterHandle =
+      instrument_detail::InstrumentHandle<instrument_detail::Counter, Derived>;
+  using UpDownCounterHandle = instrument_detail::InstrumentHandle<
+      InstrumentMetadata::UpDownCounterShape, Derived>;
+  using DoubleGaugeHandle =
+      instrument_detail::InstrumentHandle<InstrumentMetadata::DoubleGaugeShape,
+                                          Derived>;
+  using IntGaugeHandle =
+      instrument_detail::InstrumentHandle<InstrumentMetadata::IntGaugeShape,
+                                          Derived>;
+  using UintGaugeHandle =
+      instrument_detail::InstrumentHandle<InstrumentMetadata::UintGaugeShape,
+                                          Derived>;
+  template <typename Shape>
+  using HistogramHandle =
+      instrument_detail::InstrumentHandle<const Shape*, Derived>;
+
   static auto* Domain() {
     static const auto labels = Derived::Labels();
     static auto* domain =

data/src/core/transport/message_size_service_config.cc

@@ -0,0 +1,123 @@
+//
+// Copyright 2026 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.
+//
+
+#include "src/core/transport/message_size_service_config.h"
+
+#include <grpc/impl/channel_arg_names.h>
+#include <grpc/status.h>
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+
+#include "src/core/config/core_configuration.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/service_config/service_config_call_data.h"
+
+namespace grpc_core {
+
+//
+// MessageSizeParsedConfig
+//
+
+const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
+    Arena* arena, size_t service_config_parser_index) {
+  auto* svc_cfg_call_data = arena->GetContext<ServiceConfigCallData>();
+  if (svc_cfg_call_data == nullptr) return nullptr;
+  return static_cast<const MessageSizeParsedConfig*>(
+      svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index));
+}
+
+MessageSizeParsedConfig MessageSizeParsedConfig::GetFromChannelArgs(
+    const ChannelArgs& channel_args) {
+  MessageSizeParsedConfig limits;
+  limits.max_send_size_ = GetMaxSendSizeFromChannelArgs(channel_args);
+  limits.max_recv_size_ = GetMaxRecvSizeFromChannelArgs(channel_args);
+  return limits;
+}
+
+std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return std::nullopt;
+  int size = args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
+                 .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH);
+  if (size < 0) return std::nullopt;
+  return static_cast<uint32_t>(size);
+}
+
+std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return std::nullopt;
+  int size = args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
+                 .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
+  if (size < 0) return std::nullopt;
+  return static_cast<uint32_t>(size);
+}
+
+const JsonLoaderInterface* MessageSizeParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<MessageSizeParsedConfig>()
+          .OptionalField("maxRequestMessageBytes",
+                         &MessageSizeParsedConfig::max_send_size_)
+          .OptionalField("maxResponseMessageBytes",
+                         &MessageSizeParsedConfig::max_recv_size_)
+          .Finish();
+  return loader;
+}
+
+//
+// MessageSizeParser
+//
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+MessageSizeParser::ParsePerMethodParams(const ChannelArgs& /*args*/,
+                                        const Json& json,
+                                        ValidationErrors* errors) {
+  return LoadFromJson<std::unique_ptr<MessageSizeParsedConfig>>(
+      json, JsonArgs(), errors);
+}
+
+void MessageSizeParser::Register(CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      std::make_unique<MessageSizeParser>());
+}
+
+size_t MessageSizeParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+std::optional<uint32_t> GetMaxRecvSizeFromCallContext(
+    Arena* arena, std::optional<uint32_t> max_recv_size_from_channel_args) {
+  const MessageSizeParsedConfig* config_from_call_context =
+      MessageSizeParsedConfig::GetFromCallContext(
+          arena, MessageSizeParser::ParserIndex());
+  if (config_from_call_context == nullptr) {
+    return max_recv_size_from_channel_args;
+  }
+
+  if (config_from_call_context->max_recv_size().has_value() &&
+      (!max_recv_size_from_channel_args.has_value() ||
+       *config_from_call_context->max_recv_size() <
+           *max_recv_size_from_channel_args)) {
+    return config_from_call_context->max_recv_size();
+  }
+  return max_recv_size_from_channel_args;
+}
+
+}  // namespace grpc_core

data/src/core/transport/message_size_service_config.h

@@ -0,0 +1,85 @@
+//
+// Copyright 2026 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_TRANSPORT_MESSAGE_SIZE_SERVICE_CONFIG_H
+#define GRPC_SRC_CORE_TRANSPORT_MESSAGE_SIZE_SERVICE_CONFIG_H
+
+#include <grpc/support/port_platform.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <optional>
+
+#include "src/core/config/core_configuration.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/validation_errors.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
+ public:
+  std::optional<uint32_t> max_send_size() const { return max_send_size_; }
+  std::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
+
+  MessageSizeParsedConfig() = default;
+
+  MessageSizeParsedConfig(std::optional<uint32_t> max_send_size,
+                          std::optional<uint32_t> max_recv_size)
+      : max_send_size_(max_send_size), max_recv_size_(max_recv_size) {}
+
+  static const MessageSizeParsedConfig* GetFromCallContext(
+      Arena* arena, size_t service_config_parser_index);
+
+  static MessageSizeParsedConfig GetFromChannelArgs(const ChannelArgs& args);
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+
+ private:
+  std::optional<uint32_t> max_send_size_;
+  std::optional<uint32_t> max_recv_size_;
+};
+
+class MessageSizeParser : public ServiceConfigParser::Parser {
+ public:
+  absl::string_view name() const override { return parser_name(); }
+
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const ChannelArgs& /*args*/, const Json& json,
+      ValidationErrors* errors) override;
+
+  static void Register(CoreConfiguration::Builder* builder);
+
+  static size_t ParserIndex();
+
+ private:
+  static absl::string_view parser_name() { return "message_size"; }
+};
+
+std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
+std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
+std::optional<uint32_t> GetMaxRecvSizeFromCallContext(
+    Arena* arena, std::optional<uint32_t> max_recv_size_from_channel_args);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_TRANSPORT_MESSAGE_SIZE_SERVICE_CONFIG_H

data/src/core/transport/session_endpoint.cc

@@ -30,6 +30,7 @@
 #include <memory>
 #include <utility>
 
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -241,8 +242,7 @@ class SessionEndpointImpl {
         Ref();
         if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
             kShutdownBit + 1) {
-          grpc_call_cancel_internal(call_);
-          Unref();
+          CompleteShutdown();
         }
         break;
       }
@@ -251,7 +251,27 @@ class SessionEndpointImpl {
     Unref();
   }
 
+  void SetGracefulShutdown() {
+    if (!ShutdownRef()) return;
+    graceful_shutdown_ = true;
+    ShutdownUnref();
+  }
+
+  void ClearCall() { call_cleared_.store(true, std::memory_order_release); }
+
  private:
+  void CompleteShutdown() {
+    if (graceful_shutdown_ || call_cleared_.load(std::memory_order_acquire)) {
+      // Just drop our refs so the call can finish normally.
+      call_cleared_.store(true, std::memory_order_release);
+      Unref();
+    } else {
+      call_cleared_.store(true, std::memory_order_release);
+      grpc_call_cancel_internal(call_);
+      Unref();
+    }
+  }
+
   bool ShutdownRef() {
     int64_t curr = shutdown_ref_.load(std::memory_order_acquire);
     while (true) {
@@ -269,12 +289,12 @@ class SessionEndpointImpl {
   void ShutdownUnref() {
     if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
         kShutdownBit + 1) {
-      grpc_call_cancel_internal(call_);
-      Unref();
+      CompleteShutdown();
     }
   }
 
   grpc_call* const call_;
+  std::atomic<bool> call_cleared_{false};
   const bool is_client_;
 
   std::atomic<int64_t> refs_{1};
@@ -286,6 +306,7 @@ class SessionEndpointImpl {
 
   SessionEndpointTag write_tag_;
   std::atomic<bool> write_in_progress_{false};
+  bool graceful_shutdown_ = false;
 };
 
 grpc_endpoint* SessionEndpoint::Create(grpc_call* call, bool is_client) {
@@ -299,6 +320,10 @@ SessionEndpoint::SessionEndpoint(grpc_call* call, bool is_client)
 
 SessionEndpoint::~SessionEndpoint() { impl_->TriggerShutdown(); }
 
+void SessionEndpoint::SetGracefulShutdown() { impl_->SetGracefulShutdown(); }
+
+void SessionEndpoint::ClearCall() { impl_->ClearCall(); }
+
 bool SessionEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                            grpc_event_engine::experimental::SliceBuffer* buffer,
                            ReadArgs /*args*/) {

data/src/core/transport/session_endpoint.h

@@ -74,6 +74,10 @@ class SessionEndpoint
     return nullptr;
   }
 
+  void SetGracefulShutdown();
+
+  void ClearCall();
+
  private:
   SessionEndpointImpl* impl_;
   grpc_event_engine::experimental::EventEngine::ResolvedAddress local_address_;

data/src/core/tsi/alts/crypt/gsec.h

@@ -98,14 +98,16 @@ class GsecKey : public GsecKeyInterface {
 
 }  // namespace grpc_core
 
-#ifndef _STRUCT_IOVEC
+#if !defined(_STRUCT_IOVEC) && !defined(__DEFINED_struct_iovec)
 #if !defined(GRPC_EVENT_ENGINE_POSIX)
+#define _STRUCT_IOVEC
+#define __DEFINED_struct_iovec
 struct iovec {
   void* iov_base;
   size_t iov_len;
 };
 #endif  // GRPC_EVENT_ENGINE_POSIX
-#endif  // _STRUCT_IOVEC
+#endif  // !defined(_STRUCT_IOVEC) && !defined(__DEFINED_struct_iovec)
 
 //
 // A gsec interface for AEAD encryption schemes. The API is thread-compatible.

data/src/core/tsi/ssl_transport_security.cc

@@ -446,7 +446,7 @@ enum ssl_private_key_result_t TlsPrivateKeySignWrapper(
     return ssl_private_key_failure;
   }
   if (handshaker->is_shutdown) {
-    handshaker->MaybeSetError("Handshaker is shuting down");
+    handshaker->MaybeSetError("Handshaker is shutting down");
     return ssl_private_key_failure;
   }
   // Create the completion callback by binding the current context.
@@ -894,9 +894,11 @@ static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
   if (subject_alt_names != nullptr) {
     sk_GENERAL_NAME_pop_free(subject_alt_names, GENERAL_NAME_free);
   }
-  if (result != TSI_OK) tsi_peer_destruct(peer);
-
-  GRPC_CHECK((int)peer->property_count == current_insert_index);
+  if (result != TSI_OK) {
+    tsi_peer_destruct(peer);
+  } else {
+    GRPC_CHECK((int)peer->property_count == current_insert_index);
+  }
   return result;
 }
 

data/src/core/util/http_client/parser.cc

@@ -350,7 +350,7 @@ static bool check_line(grpc_http_parser* parser) {
     return true;
   }
 
-  // HTTP request with \n\r line termiantors.
+  // HTTP request with \n\r line terminators.
   else if (parser->cur_line_length >= 2 &&
            parser->cur_line[parser->cur_line_length - 2] == '\n' &&
            parser->cur_line[parser->cur_line_length - 1] == '\r') {

data/src/core/util/lru_cache.h

@@ -52,6 +52,8 @@ class LruCache {
   // the new max size.
   void SetMaxSize(size_t max_size);
 
+  size_t max_size() const { return max_size_; }
+
  private:
   struct CacheEntry {
     Value value;

data/src/core/util/ref_counted_string.h

@@ -38,7 +38,7 @@ class RefCountedString {
   RefCountedString& operator=(const RefCountedString&) = delete;
 
   // Provide the same interface as RefCounted<>.
-  // We reimplement this instead of inheritting to make pointer math
+  // We reimplement this instead of inheriting to make pointer math
   // easier in Make().
   RefCountedPtr<RefCountedString> Ref() {
     IncrementRefCount();

data/src/core/util/tchar.cc

@@ -22,21 +22,27 @@ namespace grpc_core {
 
 #if defined UNICODE || defined _UNICODE
 TcharString CharToTchar(std::string input) {
-  int needed = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, NULL, 0);
+  if (input.size() > INT_MAX) return TcharString();
+  int len = static_cast<int>(input.size());
+  int needed = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), len, nullptr, 0);
   if (needed <= 0) return TcharString();
   TcharString ret(needed, L'\0');
-  MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1,
-                      const_cast<LPTSTR>(ret.data()), needed);
+  int result =
+      MultiByteToWideChar(CP_UTF8, 0, input.c_str(), len, ret.data(), needed);
+  if (result <= 0) return TcharString();
   return ret;
 }
 
 std::string TcharToChar(TcharString input) {
-  int needed =
-      WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1, NULL, 0, NULL, NULL);
+  if (input.size() > INT_MAX) return std::string();
+  int len = static_cast<int>(input.size());
+  int needed = WideCharToMultiByte(CP_UTF8, 0, input.c_str(), len, nullptr, 0,
+                                   nullptr, nullptr);
   if (needed <= 0) return std::string();
   std::string ret(needed, '\0');
-  WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1,
-                      const_cast<LPSTR>(ret.data()), needed, NULL, NULL);
+  int result = WideCharToMultiByte(CP_UTF8, 0, input.c_str(), len, ret.data(),
+                                   needed, nullptr, nullptr);
+  if (result <= 0) return std::string();
   return ret;
 }
 #else

data/src/core/util/trie_lookup.h

@@ -154,7 +154,7 @@ class TrieLookupTree {
     if (node->value.has_value()) {
       cb(current_key, *node->value);
     }
-    // Recurse on childeren
+    // Recurse on children
     for (const auto& [character, child_node] : node->child) {
       current_key.push_back(character);
       ForEachRecursive(child_node.get(), current_key, cb);