grpc 1.55.3 → 1.56.0.pre3

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

@@ -349,10 +349,14 @@ struct cq_callback_data {
 struct grpc_completion_queue {
   /// Once owning_refs drops to zero, we will destroy the cq
   grpc_core::RefCount owning_refs;
-
+  /// Add the paddings to fix the false sharing
+  char padding_1[GPR_CACHELINE_SIZE];
   gpr_mu* mu;
 
+  char padding_2[GPR_CACHELINE_SIZE];
   const cq_vtable* vtable;
+
+  char padding_3[GPR_CACHELINE_SIZE];
   const cq_poller_vtable* poller_vtable;
 
 #ifndef NDEBUG
@@ -1231,7 +1235,7 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
     prev = &cqd->completed_head;
     while ((c = reinterpret_cast<grpc_cq_completion*>(
                 prev->next & ~uintptr_t{1})) != &cqd->completed_head) {
-      if (c->tag == tag) {
+      if (GPR_LIKELY(c->tag == tag)) {
         prev->next = (prev->next & uintptr_t{1}) | (c->next & ~uintptr_t{1});
         if (c == cqd->completed_tail) {
           cqd->completed_tail = prev;

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

@@ -21,6 +21,8 @@
 #include "src/core/lib/surface/validate_metadata.h"
 
 #include "absl/status/status.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
@@ -44,49 +46,32 @@ class LegalHeaderKeyBits : public BitSet<256> {
 };
 constexpr LegalHeaderKeyBits g_legal_header_key_bits;
 
-ValidateMetadataResult ConformsTo(absl::string_view x,
-                                  const BitSet<256>& legal_bits,
-                                  ValidateMetadataResult error) {
+GPR_ATTRIBUTE_NOINLINE
+absl::Status DoesNotConformTo(absl::string_view x, const char* err_desc) {
+  return absl::InternalError(absl::StrCat(err_desc, ": ", x, " (hex ",
+                                          absl::BytesToHexString(x), ")"));
+}
+
+absl::Status ConformsTo(absl::string_view x, const BitSet<256>& legal_bits,
+                        const char* err_desc) {
   for (uint8_t c : x) {
     if (!legal_bits.is_set(c)) {
-      return error;
+      return DoesNotConformTo(x, err_desc);
     }
   }
-  return ValidateMetadataResult::kOk;
-}
-
-absl::Status UpgradeToStatus(ValidateMetadataResult result) {
-  if (result == ValidateMetadataResult::kOk) return absl::OkStatus();
-  return absl::InternalError(ValidateMetadataResultToString(result));
+  return absl::OkStatus();
 }
-
 }  // namespace
 
-ValidateMetadataResult ValidateHeaderKeyIsLegal(absl::string_view key) {
+absl::Status ValidateHeaderKeyIsLegal(absl::string_view key) {
   if (key.empty()) {
-    return ValidateMetadataResult::kCannotBeZeroLength;
+    return absl::InternalError("Metadata keys cannot be zero length");
   }
   if (key.size() > UINT32_MAX) {
-    return ValidateMetadataResult::kTooLong;
-  }
-  return ConformsTo(key, g_legal_header_key_bits,
-                    ValidateMetadataResult::kIllegalHeaderKey);
-}
-
-const char* ValidateMetadataResultToString(ValidateMetadataResult result) {
-  switch (result) {
-    case ValidateMetadataResult::kOk:
-      return "Ok";
-    case ValidateMetadataResult::kCannotBeZeroLength:
-      return "Metadata keys cannot be zero length";
-    case ValidateMetadataResult::kTooLong:
-      return "Metadata keys cannot be larger than UINT32_MAX";
-    case ValidateMetadataResult::kIllegalHeaderKey:
-      return "Illegal header key";
-    case ValidateMetadataResult::kIllegalHeaderValue:
-      return "Illegal header value";
+    return absl::InternalError(
+        "Metadata keys cannot be larger than UINT32_MAX");
   }
-  GPR_UNREACHABLE_CODE(return "Unknown");
+  return ConformsTo(key, g_legal_header_key_bits, "Illegal header key");
 }
 
 }  // namespace grpc_core
@@ -97,8 +82,8 @@ static int error2int(grpc_error_handle error) {
 }
 
 grpc_error_handle grpc_validate_header_key_is_legal(const grpc_slice& slice) {
-  return grpc_core::UpgradeToStatus(grpc_core::ValidateHeaderKeyIsLegal(
-      grpc_core::StringViewFromSlice(slice)));
+  return grpc_core::ValidateHeaderKeyIsLegal(
+      grpc_core::StringViewFromSlice(slice));
 }
 
 int grpc_header_key_is_legal(grpc_slice slice) {
@@ -119,9 +104,9 @@ constexpr LegalHeaderNonBinValueBits g_legal_header_non_bin_value_bits;
 
 grpc_error_handle grpc_validate_header_nonbin_value_is_legal(
     const grpc_slice& slice) {
-  return grpc_core::UpgradeToStatus(grpc_core::ConformsTo(
-      grpc_core::StringViewFromSlice(slice), g_legal_header_non_bin_value_bits,
-      grpc_core::ValidateMetadataResult::kIllegalHeaderValue));
+  return grpc_core::ConformsTo(grpc_core::StringViewFromSlice(slice),
+                               g_legal_header_non_bin_value_bits,
+                               "Illegal header value");
 }
 
 int grpc_header_nonbin_value_is_legal(grpc_slice slice) {

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

@@ -25,6 +25,7 @@
 
 #include <cstring>
 
+#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
@@ -34,20 +35,9 @@
 
 namespace grpc_core {
 
-enum class ValidateMetadataResult : uint8_t {
-  kOk,
-  kCannotBeZeroLength,
-  kTooLong,
-  kIllegalHeaderKey,
-  kIllegalHeaderValue
-};
+absl::Status ValidateHeaderKeyIsLegal(absl::string_view key);
 
-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 "32.0.0"; }
+const char* grpc_version_string(void) { return "33.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "grandslam"; }
+const char* grpc_g_stands_for(void) { return "galvanized"; }

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

@@ -36,8 +36,8 @@ void BatchBuilder::PendingCompletion::CompletionCallback(
   auto* party = pc->batch->party.get();
   if (grpc_call_trace.enabled()) {
     gpr_log(
-        GPR_DEBUG, "%s[connected] Finish batch-component %s for %s: status=%s",
-        party->DebugTag().c_str(), std::string(pc->name()).c_str(),
+        GPR_DEBUG, "%sFinish batch-component %s for %s: status=%s",
+        pc->batch->DebugPrefix(party).c_str(), std::string(pc->name()).c_str(),
         grpc_transport_stream_op_batch_string(&pc->batch->batch, false).c_str(),
         error.ToString().c_str());
   }
@@ -71,6 +71,10 @@ BatchBuilder::Batch::Batch(grpc_transport_stream_op_batch_payload* payload,
 
 BatchBuilder::Batch::~Batch() {
   auto* arena = party->arena();
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "%s[connected] [batch %p] Destroy",
+            Activity::current()->DebugTag().c_str(), this);
+  }
   if (pending_receive_message != nullptr) {
     arena->DeletePooled(pending_receive_message);
   }
@@ -114,8 +118,8 @@ void BatchBuilder::FlushBatch() {
   GPR_ASSERT(target_.has_value());
   if (grpc_call_trace.enabled()) {
     gpr_log(
-        GPR_DEBUG, "%s[connected] Perform transport stream op batch: %p %s",
-        batch_->party->DebugTag().c_str(), &batch_->batch,
+        GPR_DEBUG, "%sPerform transport stream op batch: %p %s",
+        batch_->DebugPrefix().c_str(), &batch_->batch,
         grpc_transport_stream_op_batch_string(&batch_->batch, false).c_str());
   }
   std::exchange(batch_, nullptr)->PerformWith(*target_);
@@ -127,15 +131,14 @@ void BatchBuilder::Batch::PerformWith(Target target) {
 }
 
 ServerMetadataHandle BatchBuilder::CompleteSendServerTrailingMetadata(
-    ServerMetadataHandle sent_metadata, absl::Status send_result,
+    Batch* batch, ServerMetadataHandle sent_metadata, absl::Status send_result,
     bool actually_sent) {
   if (!send_result.ok()) {
     if (grpc_call_trace.enabled()) {
       gpr_log(GPR_DEBUG,
-              "%s[connected] Send metadata failed with error: %s, "
-              "fabricating trailing metadata",
-              Activity::current()->DebugTag().c_str(),
-              send_result.ToString().c_str());
+              "%sSend metadata failed with error: %s, fabricating trailing "
+              "metadata",
+              batch->DebugPrefix().c_str(), send_result.ToString().c_str());
     }
     sent_metadata->Clear();
     sent_metadata->Set(GrpcStatusMetadata(),
@@ -148,9 +151,9 @@ ServerMetadataHandle BatchBuilder::CompleteSendServerTrailingMetadata(
     if (grpc_call_trace.enabled()) {
       gpr_log(
           GPR_DEBUG,
-          "%s[connected] Tagging trailing metadata with "
-          "cancellation status from transport: %s",
-          Activity::current()->DebugTag().c_str(),
+          "%sTagging trailing metadata with cancellation status from "
+          "transport: %s",
+          batch->DebugPrefix().c_str(),
           actually_sent ? "sent => not-cancelled" : "not-sent => cancelled");
     }
     sent_metadata->Set(GrpcCallWasCancelled(), !actually_sent);

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

@@ -19,12 +19,14 @@
 
 #include <stdint.h>
 
+#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -202,6 +204,11 @@ class BatchBuilder {
     ~Batch();
     Batch(const Batch&) = delete;
     Batch& operator=(const Batch&) = delete;
+    std::string DebugPrefix(Activity* activity = Activity::current()) const {
+      return absl::StrFormat("%s[connected] [batch %p] ", activity->DebugTag(),
+                             this);
+    }
+
     void IncrementRefCount() { ++refs; }
     void Unref() {
       if (--refs == 0) party->arena()->DeletePooled(this);
@@ -222,8 +229,8 @@ class BatchBuilder {
       if (this->*field != nullptr) return this->*field;
       this->*field = party->arena()->NewPooled<T>(Ref());
       if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_DEBUG, "%s[connected] Add batch closure for %s @ %s",
-                Activity::current()->DebugTag().c_str(),
+        gpr_log(GPR_DEBUG, "%sAdd batch closure for %s @ %s",
+                DebugPrefix().c_str(),
                 std::string((this->*field)->name()).c_str(),
                 (this->*field)->on_done_closure.DebugString().c_str());
       }
@@ -273,8 +280,8 @@ class BatchBuilder {
   // Combine send status and server metadata into a final status to report back
   // to the containing call.
   static ServerMetadataHandle CompleteSendServerTrailingMetadata(
-      ServerMetadataHandle sent_metadata, absl::Status send_result,
-      bool actually_sent);
+      Batch* batch, ServerMetadataHandle sent_metadata,
+      absl::Status send_result, bool actually_sent);
 
   grpc_transport_stream_op_batch_payload* const payload_;
   absl::optional<Target> target_;
@@ -282,12 +289,11 @@ class BatchBuilder {
 };
 
 inline auto BatchBuilder::SendMessage(Target target, MessageHandle message) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue send message: %s",
-            Activity::current()->DebugTag().c_str(),
+    gpr_log(GPR_DEBUG, "%sQueue send message: %s", batch->DebugPrefix().c_str(),
             message->DebugString().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_sends);
   batch->batch.on_complete = &pc->on_done_closure;
   batch->batch.send_message = true;
@@ -299,11 +305,11 @@ inline auto BatchBuilder::SendMessage(Target target, MessageHandle message) {
 
 inline auto BatchBuilder::SendInitialMetadata(
     Target target, Arena::PoolPtr<grpc_metadata_batch> md) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue send initial metadata: %s",
-            Activity::current()->DebugTag().c_str(), md->DebugString().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue send initial metadata: %s",
+            batch->DebugPrefix().c_str(), md->DebugString().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_sends);
   batch->batch.on_complete = &pc->on_done_closure;
   batch->batch.send_initial_metadata = true;
@@ -318,11 +324,11 @@ inline auto BatchBuilder::SendClientInitialMetadata(
 }
 
 inline auto BatchBuilder::SendClientTrailingMetadata(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue send trailing metadata",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue send trailing metadata",
+            batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_sends);
   batch->batch.on_complete = &pc->on_done_closure;
   batch->batch.send_trailing_metadata = true;
@@ -342,13 +348,6 @@ inline auto BatchBuilder::SendServerInitialMetadata(
 inline auto BatchBuilder::SendServerTrailingMetadata(
     Target target, ServerMetadataHandle metadata,
     bool convert_to_cancellation) {
-  if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] %s: %s",
-            Activity::current()->DebugTag().c_str(),
-            convert_to_cancellation ? "Send trailing metadata as cancellation"
-                                    : "Queue send trailing metadata",
-            metadata->DebugString().c_str());
-  }
   Batch* batch;
   PendingSends* pc;
   if (convert_to_cancellation) {
@@ -368,14 +367,20 @@ inline auto BatchBuilder::SendServerTrailingMetadata(
     payload_->send_trailing_metadata.send_trailing_metadata = metadata.get();
     payload_->send_trailing_metadata.sent = &pc->trailing_metadata_sent;
   }
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "%s%s: %s", batch->DebugPrefix().c_str(),
+            convert_to_cancellation ? "Send trailing metadata as cancellation"
+                                    : "Queue send trailing metadata",
+            metadata->DebugString().c_str());
+  }
   batch->batch.on_complete = &pc->on_done_closure;
   pc->send_trailing_metadata = std::move(metadata);
-  auto promise = batch->RefUntil(
-      Map(pc->done_latch.WaitAndCopy(), [pc](absl::Status status) {
-        return CompleteSendServerTrailingMetadata(
-            std::move(pc->send_trailing_metadata), std::move(status),
-            pc->trailing_metadata_sent);
-      }));
+  auto promise = Map(pc->done_latch.WaitAndCopy(),
+                     [pc, batch = batch->Ref()](absl::Status status) {
+                       return CompleteSendServerTrailingMetadata(
+                           batch.get(), std::move(pc->send_trailing_metadata),
+                           std::move(status), pc->trailing_metadata_sent);
+                     });
   if (convert_to_cancellation) {
     batch->PerformWith(target);
   }
@@ -383,11 +388,10 @@ inline auto BatchBuilder::SendServerTrailingMetadata(
 }
 
 inline auto BatchBuilder::ReceiveMessage(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue receive message",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue receive message", batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_receive_message);
   batch->batch.recv_message = true;
   payload_->recv_message.recv_message_ready = &pc->on_done_closure;
@@ -411,11 +415,11 @@ inline auto BatchBuilder::ReceiveMessage(Target target) {
 }
 
 inline auto BatchBuilder::ReceiveInitialMetadata(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue receive initial metadata",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue receive initial metadata",
+            batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc =
       batch->GetInitializedCompletion(&Batch::pending_receive_initial_metadata);
   batch->batch.recv_initial_metadata = true;
@@ -439,11 +443,11 @@ inline auto BatchBuilder::ReceiveServerInitialMetadata(Target target) {
 }
 
 inline auto BatchBuilder::ReceiveTrailingMetadata(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue receive trailing metadata",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue receive trailing metadata",
+            batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(
       &Batch::pending_receive_trailing_metadata);
   batch->batch.recv_trailing_metadata = true;

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -62,7 +62,6 @@ extern void RegisterPickFirstLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterRoundRobinLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterWeightedRoundRobinLbPolicy(
     CoreConfiguration::Builder* builder);
-extern void RegisterRingHashLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 #ifndef GRPC_NO_RLS
 extern void RegisterRlsLbPolicy(CoreConfiguration::Builder* builder);
@@ -85,7 +84,6 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterPickFirstLbPolicy(builder);
   RegisterRoundRobinLbPolicy(builder);
   RegisterWeightedRoundRobinLbPolicy(builder);
-  RegisterRingHashLbPolicy(builder);
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
   RegisterClientAuthorityFilter(builder);

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -39,6 +39,7 @@ extern void RegisterXdsClusterResolverLbPolicy(
 extern void RegisterXdsOverrideHostLbPolicy(
     CoreConfiguration::Builder* builder);
 extern void RegisterXdsWrrLocalityLbPolicy(CoreConfiguration::Builder* builder);
+extern void RegisterRingHashLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterFileWatcherCertificateProvider(
     CoreConfiguration::Builder* builder);
 #endif
@@ -60,6 +61,7 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   RegisterXdsClusterResolverLbPolicy(builder);
   RegisterXdsOverrideHostLbPolicy(builder);
   RegisterXdsWrrLocalityLbPolicy(builder);
+  RegisterRingHashLbPolicy(builder);
   RegisterFileWatcherCertificateProvider(builder);
 #endif
 }

data/src/ruby/ext/grpc/extconf.rb

@@ -34,24 +34,23 @@ def env_unset?(name)
   ENV[name].nil? || ENV[name].size == 0
 end
 
-def rbconfig_set?(name)
-  RbConfig::CONFIG[name] && RbConfig::CONFIG[name].size > 0
+def inherit_env_or_rbconfig(name)
+  ENV[name] = inherit_rbconfig(name) if env_unset?(name)
 end
 
 def inherit_rbconfig(name)
-  ENV[name] = RbConfig::CONFIG[name] if env_unset?(name) && rbconfig_set?(name)
+  ENV[name] = RbConfig::CONFIG[name] || ''
 end
 
 def env_append(name, string)
-  ENV[name] ||= ''
   ENV[name] += ' ' + string
 end
 
-inherit_rbconfig 'AR'
-inherit_rbconfig 'CC'
-inherit_rbconfig 'CXX'
-inherit_rbconfig 'RANLIB'
-inherit_rbconfig 'STRIP'
+inherit_env_or_rbconfig 'AR'
+inherit_env_or_rbconfig 'CC'
+inherit_env_or_rbconfig 'CXX'
+inherit_env_or_rbconfig 'RANLIB'
+inherit_env_or_rbconfig 'STRIP'
 inherit_rbconfig 'CPPFLAGS'
 inherit_rbconfig 'LDFLAGS'
 

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

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

data/third_party/boringssl-with-bazel/src/crypto/asn1/a_mbstr.c

@@ -73,18 +73,19 @@
 // horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
 // size limits too.
 
-int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
-                       int inform, unsigned long mask) {
-  return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0);
+int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in,
+                       ossl_ssize_t len, int inform, unsigned long mask) {
+  return ASN1_mbstring_ncopy(out, in, len, inform, mask, /*minsize=*/0,
+                             /*maxsize=*/0);
 }
 
 OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_BMPSTRING)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UNIVERSALSTRING)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UTF8STRING)
 
-int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
-                        int inform, unsigned long mask, long minsize,
-                        long maxsize) {
+int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in,
+                        ossl_ssize_t len, int inform, unsigned long mask,
+                        ossl_ssize_t minsize, ossl_ssize_t maxsize) {
   if (len == -1) {
     len = strlen((const char *)in);
   }
@@ -164,14 +165,14 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
     utf8_len += cbb_get_utf8_len(c);
     if (maxsize > 0 && nchar > (size_t)maxsize) {
       OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_LONG);
-      ERR_add_error_dataf("maxsize=%ld", maxsize);
+      ERR_add_error_dataf("maxsize=%zu", (size_t)maxsize);
       return -1;
     }
   }
 
   if (minsize > 0 && nchar < (size_t)minsize) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT);
-    ERR_add_error_dataf("minsize=%ld", minsize);
+    ERR_add_error_dataf("minsize=%zu", (size_t)minsize);
     return -1;
   }
 

data/third_party/boringssl-with-bazel/src/crypto/asn1/a_strnid.c

@@ -87,7 +87,7 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid);
 // a corresponding OID. For example certificates and certificate requests.
 
 ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in,
-                                    int len, int inform, int nid) {
+                                    ossl_ssize_t len, int inform, int nid) {
   ASN1_STRING *str = NULL;
   int ret;
   if (!out) {

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

@@ -56,8 +56,8 @@
  *
  */
 
-#ifndef OPENSSL_HEADER_ASN1_ASN1_LOCL_H
-#define OPENSSL_HEADER_ASN1_ASN1_LOCL_H
+#ifndef OPENSSL_HEADER_ASN1_INTERNAL_H
+#define OPENSSL_HEADER_ASN1_INTERNAL_H
 
 #include <time.h>
 
@@ -266,4 +266,4 @@ typedef struct ASN1_EXTERN_FUNCS_st {
 }  // extern C
 #endif
 
-#endif  // OPENSSL_HEADER_ASN1_ASN1_LOCL_H
+#endif  // OPENSSL_HEADER_ASN1_INTERNAL_H

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_dec.c

@@ -85,7 +85,7 @@ static int asn1_template_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
 static int asn1_template_noexp_d2i(ASN1_VALUE **val, const unsigned char **in,
                                    long len, const ASN1_TEMPLATE *tt, char opt,
                                    CRYPTO_BUFFER *buf, int depth);
-static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
+static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len,
                        int utype, const ASN1_ITEM *it);
 static int asn1_d2i_ex_primitive(ASN1_VALUE **pval, const unsigned char **in,
                                  long len, const ASN1_ITEM *it, int tag,
@@ -749,7 +749,7 @@ err:
 
 // Translate ASN1 content octets into a structure
 
-static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
+static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len,
                        int utype, const ASN1_ITEM *it) {
   ASN1_VALUE **opval = NULL;
   ASN1_STRING *stmp;
@@ -837,7 +837,14 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
     case V_ASN1_UTF8STRING:
     case V_ASN1_OTHER:
     case V_ASN1_SET:
-    case V_ASN1_SEQUENCE: {
+    case V_ASN1_SEQUENCE:
+    // TODO(crbug.com/boringssl/412): This default case should be removed, now
+    // that we've resolved https://crbug.com/boringssl/561. However, it is still
+    // needed to support some edge cases in |ASN1_PRINTABLE|. |ASN1_PRINTABLE|
+    // broadly doesn't tolerate unrecognized universal tags, but except for
+    // eight values that map to |B_ASN1_UNKNOWN| instead of zero. See the
+    // X509Test.NameAttributeValues test.
+    default: {
       CBS cbs;
       CBS_init(&cbs, cont, (size_t)len);
       if (utype == V_ASN1_BMPSTRING) {
@@ -900,9 +907,6 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
       }
       break;
     }
-    default:
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
-      goto err;
   }
   // If ASN1_ANY and NULL type fix up value
   if (typ && (utype == V_ASN1_NULL)) {

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_enc.c

@@ -693,15 +693,18 @@ static int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cout, int *out_omit,
     case V_ASN1_SET:
     // This is not a valid |ASN1_ITEM| type, but it appears in |ASN1_TYPE|.
     case V_ASN1_OTHER:
+    // TODO(crbug.com/boringssl/412): This default case should be removed, now
+    // that we've resolved https://crbug.com/boringssl/561. However, it is still
+    // needed to support some edge cases in |ASN1_PRINTABLE|. |ASN1_PRINTABLE|
+    // broadly doesn't tolerate unrecognized universal tags, but except for
+    // eight values that map to |B_ASN1_UNKNOWN| instead of zero. See the
+    // X509Test.NameAttributeValues test.
+    default:
       // All based on ASN1_STRING and handled the same
       strtmp = (ASN1_STRING *)*pval;
       cont = strtmp->data;
       len = strtmp->length;
       break;
-
-    default:
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
-      return -1;
   }
   if (cout && len) {
     OPENSSL_memcpy(cout, cont, len);

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

@@ -423,7 +423,7 @@ int BIO_indent(BIO *bio, unsigned indent, unsigned max_indent) {
 }
 
 static int print_bio(const char *str, size_t len, void *bio) {
-  return BIO_write((BIO *)bio, str, len);
+  return BIO_write_all((BIO *)bio, str, len);
 }
 
 void ERR_print_errors(BIO *bio) {
@@ -462,9 +462,11 @@ static int bio_read_all(BIO *bio, uint8_t **out, size_t *out_len,
       OPENSSL_free(*out);
       return 0;
     }
-    const size_t todo = len - done;
-    assert(todo < INT_MAX);
-    const int n = BIO_read(bio, *out + done, todo);
+    size_t todo = len - done;
+    if (todo > INT_MAX) {
+      todo = INT_MAX;
+    }
+    const int n = BIO_read(bio, *out + done, (int)todo);
     if (n == 0) {
       *out_len = done;
       return 1;

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

@@ -257,7 +257,8 @@ static int fd_gets(BIO *bp, char *buf, int size) {
 
   ptr[0] = '\0';
 
-  return ptr - buf;
+  // The output length is bounded by |size|.
+  return (int)(ptr - buf);
 }
 
 static const BIO_METHOD methods_fdp = {