grpc 1.44.0.pre2 → 1.46.3

data/src/core/ext/transport/chttp2/transport/hpack_encoder.h

@@ -80,7 +80,7 @@ class HPackCompressor {
     void Encode(HttpPathMetadata, const Slice& value);
     void Encode(HttpAuthorityMetadata, const Slice& value);
     void Encode(HttpStatusMetadata, uint32_t status);
-    void Encode(GrpcTimeoutMetadata, grpc_millis deadline);
+    void Encode(GrpcTimeoutMetadata, Timestamp deadline);
     void Encode(TeMetadata, TeMetadata::ValueType value);
     void Encode(ContentTypeMetadata, ContentTypeMetadata::ValueType value);
     void Encode(HttpSchemeMetadata, HttpSchemeMetadata::ValueType value);

data/src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -647,17 +647,6 @@ class HPackParser::Input {
 // Helper to parse a string and turn it into a slice with appropriate memory
 // management characteristics
 class HPackParser::String {
- public:
-  // Helper to specify a string should be internalized
-  struct Intern {};
-  // Helper to specify a string should be externalized
-  struct Extern {};
-
- private:
-  // Forward declare take functions... we'll need them in the public interface
-  Slice Take(Extern);
-  Slice Take(Intern);
-
  public:
   String(const String&) = delete;
   String& operator=(const String&) = delete;
@@ -671,11 +660,7 @@ class HPackParser::String {
   }
 
   // Take the value and leave this empty
-  // Use Intern/Extern to choose memory management
-  template <typename T>
-  auto Take() -> decltype(this->Take(T())) {
-    return Take(T());
-  }
+  Slice Take();
 
   // Return a reference to the value as a string view
   absl::string_view string_view() const {
@@ -962,13 +947,11 @@ class HPackParser::Parser {
       case 1:
         switch (cur & 0xf) {
           case 0:  // literal key
-            return FinishHeaderOmitFromTable(ParseLiteralKey<String::Extern>());
+            return FinishHeaderOmitFromTable(ParseLiteralKey());
           case 0xf:  // varint encoded key index
-            return FinishHeaderOmitFromTable(
-                ParseVarIdxKey<String::Extern>(0xf));
+            return FinishHeaderOmitFromTable(ParseVarIdxKey(0xf));
           default:  // inline encoded key index
-            return FinishHeaderOmitFromTable(
-                ParseIdxKey<String::Extern>(cur & 0xf));
+            return FinishHeaderOmitFromTable(ParseIdxKey(cur & 0xf));
         }
         // Update max table size.
         // First byte format: 001xxxxx
@@ -995,23 +978,20 @@ class HPackParser::Parser {
       case 4:
         if (cur == 0x40) {
           // literal key
-          return FinishHeaderAndAddToTable(ParseLiteralKey<String::Intern>());
+          return FinishHeaderAndAddToTable(ParseLiteralKey());
         }
         ABSL_FALLTHROUGH_INTENDED;
       case 5:
       case 6:
         // inline encoded key index
-        return FinishHeaderAndAddToTable(
-            ParseIdxKey<String::Intern>(cur & 0x3f));
+        return FinishHeaderAndAddToTable(ParseIdxKey(cur & 0x3f));
       case 7:
         if (cur == 0x7f) {
           // varint encoded key index
-          return FinishHeaderAndAddToTable(
-              ParseVarIdxKey<String::Intern>(0x3f));
+          return FinishHeaderAndAddToTable(ParseVarIdxKey(0x3f));
         } else {
           // inline encoded key index
-          return FinishHeaderAndAddToTable(
-              ParseIdxKey<String::Intern>(cur & 0x3f));
+          return FinishHeaderAndAddToTable(ParseIdxKey(cur & 0x3f));
         }
         // Indexed Header Field Representation
         // First byte format: 1xxxxxxx
@@ -1113,7 +1093,6 @@ class HPackParser::Parser {
   }
 
   // Parse a string encoded key and a string encoded value
-  template <typename TakeValueType>
   absl::optional<HPackTable::Memento> ParseLiteralKey() {
     auto key = String::Parse(input_);
     if (!key.has_value()) return {};
@@ -1122,7 +1101,7 @@ class HPackParser::Parser {
       return {};
     }
     auto key_string = key->string_view();
-    auto value_slice = value->Take<TakeValueType>();
+    auto value_slice = value->Take();
     const auto transport_size = key_string.size() + value_slice.size() +
                                 hpack_constants::kEntryOverhead;
     return grpc_metadata_batch::Parse(
@@ -1133,7 +1112,6 @@ class HPackParser::Parser {
   }
 
   // Parse an index encoded key and a string encoded value
-  template <typename TakeValueType>
   absl::optional<HPackTable::Memento> ParseIdxKey(uint32_t index) {
     const auto* elem = table_->Lookup(index);
     if (GPR_UNLIKELY(elem == nullptr)) {
@@ -1142,19 +1120,17 @@ class HPackParser::Parser {
     }
     auto value = ParseValueString(elem->is_binary_header());
     if (GPR_UNLIKELY(!value.has_value())) return {};
-    return elem->WithNewValue(value->Take<TakeValueType>(),
-                              [=](absl::string_view error, const Slice& value) {
-                                ReportMetadataParseError(
-                                    elem->key(), error, value.as_string_view());
-                              });
+    return elem->WithNewValue(
+        value->Take(), [=](absl::string_view error, const Slice& value) {
+          ReportMetadataParseError(elem->key(), error, value.as_string_view());
+        });
   }
 
   // Parse a varint index encoded key and a string encoded value
-  template <typename TakeValueType>
   absl::optional<HPackTable::Memento> ParseVarIdxKey(uint32_t offset) {
     auto index = input_->ParseVarint(offset);
     if (GPR_UNLIKELY(!index.has_value())) return {};
-    return ParseIdxKey<TakeValueType>(*index);
+    return ParseIdxKey(*index);
   }
 
   // Parse a string, figuring out if it's binary or not by the key name.
@@ -1250,7 +1226,7 @@ class HPackParser::Parser {
   const LogInfo log_info_;
 };
 
-Slice HPackParser::String::Take(Extern) {
+Slice HPackParser::String::Take() {
   if (auto* p = absl::get_if<Slice>(&value_)) {
     return p->Copy();
   } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
@@ -1261,18 +1237,6 @@ Slice HPackParser::String::Take(Extern) {
   GPR_UNREACHABLE_CODE(return Slice());
 }
 
-Slice HPackParser::String::Take(Intern) {
-  ManagedMemorySlice m;
-  if (auto* p = absl::get_if<Slice>(&value_)) {
-    m = ManagedMemorySlice(&p->c_slice());
-  } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
-    m = ManagedMemorySlice(reinterpret_cast<const char*>(p->data()), p->size());
-  } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
-    m = ManagedMemorySlice(reinterpret_cast<const char*>(p->data()), p->size());
-  }
-  return Slice(m);
-}
-
 /* PUBLIC INTERFACE */
 
 HPackParser::HPackParser() = default;

data/src/core/ext/transport/chttp2/transport/hpack_parser_table.cc

@@ -226,8 +226,8 @@ GPR_ATTRIBUTE_NOINLINE HPackTable::Memento MakeMemento(size_t i) {
 }  // namespace
 
 const HPackTable::StaticMementos& HPackTable::GetStaticMementos() {
-  static const StaticMementos static_mementos;
-  return static_mementos;
+  static const StaticMementos* const static_mementos = new StaticMementos();
+  return *static_mementos;
 }
 
 HPackTable::StaticMementos::StaticMementos() {

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -98,6 +98,7 @@ typedef enum {
   GRPC_CHTTP2_INITIATE_WRITE_STREAM_FLOW_CONTROL,
   GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL,
   GRPC_CHTTP2_INITIATE_WRITE_SEND_SETTINGS,
+  GRPC_CHTTP2_INITIATE_WRITE_SETTINGS_ACK,
   GRPC_CHTTP2_INITIATE_WRITE_FLOW_CONTROL_UNSTALLED_BY_SETTING,
   GRPC_CHTTP2_INITIATE_WRITE_FLOW_CONTROL_UNSTALLED_BY_UPDATE,
   GRPC_CHTTP2_INITIATE_WRITE_APPLICATION_PING,
@@ -118,16 +119,16 @@ struct grpc_chttp2_ping_queue {
 struct grpc_chttp2_repeated_ping_policy {
   int max_pings_without_data;
   int max_ping_strikes;
-  grpc_millis min_recv_ping_interval_without_data;
+  grpc_core::Duration min_recv_ping_interval_without_data;
 };
 struct grpc_chttp2_repeated_ping_state {
-  grpc_millis last_ping_sent_time;
+  grpc_core::Timestamp last_ping_sent_time;
   int pings_before_data_required;
   grpc_timer delayed_ping_timer;
   bool is_delayed_ping_timer_set;
 };
 struct grpc_chttp2_server_ping_recv_state {
-  grpc_millis last_ping_recv_time;
+  grpc_core::Timestamp last_ping_recv_time;
   int ping_strikes;
 };
 /* deframer state for the overall http2 stream of bytes */
@@ -196,8 +197,9 @@ typedef enum {
 
 typedef enum {
   GRPC_CHTTP2_NO_GOAWAY_SEND,
-  GRPC_CHTTP2_GOAWAY_SEND_SCHEDULED,
-  GRPC_CHTTP2_GOAWAY_SENT,
+  GRPC_CHTTP2_GRACEFUL_GOAWAY,
+  GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED,
+  GRPC_CHTTP2_FINAL_GOAWAY_SENT,
 } grpc_chttp2_sent_goaway_state;
 
 typedef struct grpc_chttp2_write_cb {
@@ -477,9 +479,9 @@ struct grpc_chttp2_transport {
   /** watchdog to kill the transport when waiting for the keepalive ping */
   grpc_timer keepalive_watchdog_timer;
   /** time duration in between pings */
-  grpc_millis keepalive_time;
+  grpc_core::Duration keepalive_time;
   /** grace period for a ping to complete before watchdog kicks in */
-  grpc_millis keepalive_timeout;
+  grpc_core::Duration keepalive_timeout;
   /** if keepalive pings are allowed when there's no outstanding streams */
   bool keepalive_permit_without_calls = false;
   /** If start_keepalive_ping_locked has been called */
@@ -609,7 +611,7 @@ struct grpc_chttp2_stream {
       GRPC_ERROR_NONE;              /* protected by t combiner */
   bool received_last_frame = false; /* protected by t combiner */
 
-  grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
+  grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
   /** saw some stream level error */
   grpc_error_handle forced_close_error = GRPC_ERROR_NONE;

data/src/core/ext/transport/chttp2/transport/parsing.cc

@@ -28,8 +28,8 @@
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/timeout_encoding.h"
@@ -400,7 +400,7 @@ error_handler:
     /* t->parser = grpc_chttp2_data_parser_parse;*/
     t->parser = grpc_chttp2_data_parser_parse;
     t->parser_data = &s->data_parser;
-    t->ping_state.last_ping_sent_time = GRPC_MILLIS_INF_PAST;
+    t->ping_state.last_ping_sent_time = grpc_core::Timestamp::InfPast();
     return GRPC_ERROR_NONE;
   } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, &unused)) {
     /* handle stream errors by closing the stream */
@@ -440,7 +440,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                  ? HPackParser::Priority::Included
                                  : HPackParser::Priority::None;
 
-  t->ping_state.last_ping_sent_time = GRPC_MILLIS_INF_PAST;
+  t->ping_state.last_ping_sent_time = grpc_core::Timestamp::InfPast();
 
   /* could be a new grpc_chttp2_stream or an existing grpc_chttp2_stream */
   s = grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
@@ -479,6 +479,14 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                    t->settings[GRPC_ACKED_SETTINGS]
                               [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Max stream count exceeded");
+    } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT) {
+      GRPC_CHTTP2_IF_TRACING(gpr_log(
+          GPR_INFO,
+          "transport:%p SERVER peer:%s Final GOAWAY sent. Ignoring new "
+          "grpc_chttp2_stream request id=%d, last grpc_chttp2_stream id=%d",
+          t, t->peer_string.c_str(), t->incoming_stream_id,
+          t->last_new_stream_id));
+      return init_header_skip_frame_parser(t, priority_type);
     }
     t->last_new_stream_id = t->incoming_stream_id;
     s = t->incoming_stream =

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -60,15 +60,15 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
     }
     return;
   }
-  if (t->ping_state.pings_before_data_required == 0 &&
+  if (t->is_client && t->ping_state.pings_before_data_required == 0 &&
       t->ping_policy.max_pings_without_data != 0) {
     /* need to receive something of substance before sending a ping again */
     if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
         GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
         GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
-      gpr_log(GPR_INFO, "%s: Ping delayed [%s]: too many recent pings: %d/%d",
-              t->is_client ? "CLIENT" : "SERVER", t->peer_string.c_str(),
-              t->ping_state.pings_before_data_required,
+      gpr_log(GPR_INFO,
+              "CLIENT: Ping delayed [%s]: too many recent pings: %d/%d",
+              t->peer_string.c_str(), t->ping_state.pings_before_data_required,
               t->ping_policy.max_pings_without_data);
     }
     return;
@@ -77,15 +77,26 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
   // in a loop while draining the currently-held combiner. Also see
   // https://github.com/grpc/grpc/issues/26079.
   grpc_core::ExecCtx::Get()->InvalidateNow();
-  grpc_millis now = grpc_core::ExecCtx::Get()->Now();
-
-  grpc_millis next_allowed_ping_interval =
-      (t->keepalive_permit_without_calls == 0 &&
-       grpc_chttp2_stream_map_size(&t->stream_map) == 0)
-          ? 7200 * GPR_MS_PER_SEC
-          : (GPR_MS_PER_SEC); /* A second is added to deal with network delays
-                                 and timing imprecision */
-  grpc_millis next_allowed_ping =
+  grpc_core::Timestamp now = grpc_core::ExecCtx::Get()->Now();
+
+  grpc_core::Duration next_allowed_ping_interval = grpc_core::Duration::Zero();
+  if (t->is_client) {
+    next_allowed_ping_interval =
+        (t->keepalive_permit_without_calls == 0 &&
+         grpc_chttp2_stream_map_size(&t->stream_map) == 0)
+            ? grpc_core::Duration::Hours(2)
+            : grpc_core::Duration::Seconds(1); /* A second is added to deal with
+                         network delays and timing imprecision */
+  } else if (t->sent_goaway_state != GRPC_CHTTP2_GRACEFUL_GOAWAY) {
+    // The gRPC keepalive spec doesn't call for any throttling on the server
+    // side, but we are adding some throttling for protection anyway, unless
+    // we are doing a graceful GOAWAY in which case we don't want to wait.
+    next_allowed_ping_interval =
+        t->keepalive_time == grpc_core::Duration::Infinity()
+            ? grpc_core::Duration::Seconds(20)
+            : t->keepalive_time / 2;
+  }
+  grpc_core::Timestamp next_allowed_ping =
       t->ping_state.last_ping_sent_time + next_allowed_ping_interval;
 
   if (next_allowed_ping > now) {
@@ -93,12 +104,15 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
         GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
         GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
-      gpr_log(GPR_INFO,
-              "%s: Ping delayed [%s]: not enough time elapsed since last ping. "
-              " Last ping %f: Next ping %f: Now %f",
-              t->is_client ? "CLIENT" : "SERVER", t->peer_string.c_str(),
-              static_cast<double>(t->ping_state.last_ping_sent_time),
-              static_cast<double>(next_allowed_ping), static_cast<double>(now));
+      gpr_log(
+          GPR_INFO,
+          "%s: Ping delayed [%s]: not enough time elapsed since last "
+          "ping. "
+          " Last ping %" PRId64 ": Next ping %" PRId64 ": Now %" PRId64,
+          t->is_client ? "CLIENT" : "SERVER", t->peer_string.c_str(),
+          t->ping_state.last_ping_sent_time.milliseconds_after_process_epoch(),
+          next_allowed_ping.milliseconds_after_process_epoch(),
+          now.milliseconds_after_process_epoch());
     }
     if (!t->ping_state.is_delayed_ping_timer_set) {
       t->ping_state.is_delayed_ping_timer_set = true;
@@ -111,6 +125,7 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
     }
     return;
   }
+  t->ping_state.last_ping_sent_time = now;
 
   pq->inflight_id = t->ping_ctr;
   t->ping_ctr++;
@@ -121,7 +136,6 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
   grpc_slice_buffer_add(&t->outbuf,
                         grpc_chttp2_ping_create(false, pq->inflight_id));
   GRPC_STATS_INC_HTTP2_PINGS_SENT();
-  t->ping_state.last_ping_sent_time = now;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
       GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
       GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -231,7 +231,8 @@ struct inproc_stream {
   grpc_metadata_batch write_buffer_initial_md{arena};
   bool write_buffer_initial_md_filled = false;
   uint32_t write_buffer_initial_md_flags = 0;
-  grpc_millis write_buffer_deadline = GRPC_MILLIS_INF_FUTURE;
+  grpc_core::Timestamp write_buffer_deadline =
+      grpc_core::Timestamp::InfFuture();
   grpc_metadata_batch write_buffer_trailing_md{arena};
   bool write_buffer_trailing_md_filled = false;
   grpc_error_handle write_buffer_cancel_error = GRPC_ERROR_NONE;
@@ -265,7 +266,7 @@ struct inproc_stream {
   grpc_error_handle cancel_self_error = GRPC_ERROR_NONE;
   grpc_error_handle cancel_other_error = GRPC_ERROR_NONE;
 
-  grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
+  grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
   bool listed = true;
   struct inproc_stream* stream_list_prev;
@@ -705,7 +706,7 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
               .recv_initial_metadata,
           s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
           nullptr);
-      if (s->deadline != GRPC_MILLIS_INF_FUTURE) {
+      if (s->deadline != grpc_core::Timestamp::InfFuture()) {
         s->recv_initial_md_op->payload->recv_initial_metadata
             .recv_initial_metadata->Set(grpc_core::GrpcTimeoutMetadata(),
                                         s->deadline);
@@ -1008,12 +1009,12 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
               dest, destflags, destfilled);
         }
         if (s->t->is_client) {
-          grpc_millis* dl =
+          grpc_core::Timestamp* dl =
               (other == nullptr) ? &s->write_buffer_deadline : &other->deadline;
           *dl = std::min(
               *dl, op->payload->send_initial_metadata.send_initial_metadata
                        ->get(grpc_core::GrpcTimeoutMetadata())
-                       .value_or(GRPC_MILLIS_INF_FUTURE));
+                       .value_or(grpc_core::Timestamp::InfFuture()));
           s->initial_md_sent = true;
         }
       }
@@ -1212,9 +1213,11 @@ void set_pollset_set(grpc_transport* /*gt*/, grpc_stream* /*gs*/,
 grpc_endpoint* get_endpoint(grpc_transport* /*t*/) { return nullptr; }
 
 const grpc_transport_vtable inproc_vtable = {
-    sizeof(inproc_stream), "inproc",        init_stream,
-    set_pollset,           set_pollset_set, perform_stream_op,
-    perform_transport_op,  destroy_stream,  destroy_transport,
+    sizeof(inproc_stream), "inproc",
+    init_stream,           nullptr,
+    set_pollset,           set_pollset_set,
+    perform_stream_op,     perform_transport_op,
+    destroy_stream,        destroy_transport,
     get_endpoint};
 
 /*******************************************************************************
@@ -1273,9 +1276,9 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
       server_transport, nullptr, server_args, nullptr);
   grpc_channel* channel = nullptr;
   if (error == GRPC_ERROR_NONE) {
-    channel =
-        grpc_channel_create("inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL,
-                            client_transport, &error);
+    channel = grpc_channel_create_internal("inproc", client_args,
+                                           GRPC_CLIENT_DIRECT_CHANNEL,
+                                           client_transport, &error);
     if (error != GRPC_ERROR_NONE) {
       GPR_ASSERT(!channel);
       gpr_log(GPR_ERROR, "Failed to create client channel: %s",
@@ -1286,7 +1289,8 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
         status = static_cast<grpc_status_code>(integer);
       }
       GRPC_ERROR_UNREF(error);
-      // client_transport was destroyed when grpc_channel_create saw an error.
+      // client_transport was destroyed when grpc_channel_create_internal saw an
+      // error.
       grpc_transport_destroy(server_transport);
       channel = grpc_lame_client_channel_create(
           nullptr, status, "Failed to create client channel");

data/src/core/ext/upb-generated/envoy/admin/v3/certs.upb.c

@@ -0,0 +1,117 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     envoy/admin/v3/certs.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#include <stddef.h>
+#include "upb/msg_internal.h"
+#include "envoy/admin/v3/certs.upb.h"
+#include "google/protobuf/timestamp.upb.h"
+#include "udpa/annotations/status.upb.h"
+#include "udpa/annotations/versioning.upb.h"
+
+#include "upb/port_def.inc"
+
+static const upb_MiniTable_Sub envoy_admin_v3_Certificates_submsgs[1] = {
+  {.submsg = &envoy_admin_v3_Certificate_msginit},
+};
+
+static const upb_MiniTable_Field envoy_admin_v3_Certificates__fields[1] = {
+  {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_admin_v3_Certificates_msginit = {
+  &envoy_admin_v3_Certificates_submsgs[0],
+  &envoy_admin_v3_Certificates__fields[0],
+  UPB_SIZE(4, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+};
+
+static const upb_MiniTable_Sub envoy_admin_v3_Certificate_submsgs[2] = {
+  {.submsg = &envoy_admin_v3_CertificateDetails_msginit},
+  {.submsg = &envoy_admin_v3_CertificateDetails_msginit},
+};
+
+static const upb_MiniTable_Field envoy_admin_v3_Certificate__fields[2] = {
+  {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {2, UPB_SIZE(4, 8), UPB_SIZE(0, 0), 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_admin_v3_Certificate_msginit = {
+  &envoy_admin_v3_Certificate_submsgs[0],
+  &envoy_admin_v3_Certificate__fields[0],
+  UPB_SIZE(8, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+};
+
+static const upb_MiniTable_Sub envoy_admin_v3_CertificateDetails_submsgs[4] = {
+  {.submsg = &envoy_admin_v3_SubjectAlternateName_msginit},
+  {.submsg = &google_protobuf_Timestamp_msginit},
+  {.submsg = &google_protobuf_Timestamp_msginit},
+  {.submsg = &envoy_admin_v3_CertificateDetails_OcspDetails_msginit},
+};
+
+static const upb_MiniTable_Field envoy_admin_v3_CertificateDetails__fields[7] = {
+  {1, UPB_SIZE(4, 8), UPB_SIZE(0, 0), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+  {2, UPB_SIZE(12, 24), UPB_SIZE(0, 0), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+  {3, UPB_SIZE(20, 40), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {4, UPB_SIZE(40, 72), UPB_SIZE(0, 0), kUpb_NoSub, 4, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+  {5, UPB_SIZE(24, 48), UPB_SIZE(1, 1), 1, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {6, UPB_SIZE(28, 56), UPB_SIZE(2, 2), 2, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {7, UPB_SIZE(32, 64), UPB_SIZE(3, 3), 3, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_admin_v3_CertificateDetails_msginit = {
+  &envoy_admin_v3_CertificateDetails_submsgs[0],
+  &envoy_admin_v3_CertificateDetails__fields[0],
+  UPB_SIZE(48, 88), 7, kUpb_ExtMode_NonExtendable, 7, 255, 0,
+};
+
+static const upb_MiniTable_Sub envoy_admin_v3_CertificateDetails_OcspDetails_submsgs[2] = {
+  {.submsg = &google_protobuf_Timestamp_msginit},
+  {.submsg = &google_protobuf_Timestamp_msginit},
+};
+
+static const upb_MiniTable_Field envoy_admin_v3_CertificateDetails_OcspDetails__fields[2] = {
+  {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {2, UPB_SIZE(8, 16), UPB_SIZE(2, 2), 1, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_admin_v3_CertificateDetails_OcspDetails_msginit = {
+  &envoy_admin_v3_CertificateDetails_OcspDetails_submsgs[0],
+  &envoy_admin_v3_CertificateDetails_OcspDetails__fields[0],
+  UPB_SIZE(12, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+};
+
+static const upb_MiniTable_Field envoy_admin_v3_SubjectAlternateName__fields[3] = {
+  {1, UPB_SIZE(4, 8), UPB_SIZE(-1, -1), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+  {2, UPB_SIZE(4, 8), UPB_SIZE(-1, -1), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+  {3, UPB_SIZE(4, 8), UPB_SIZE(-1, -1), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_admin_v3_SubjectAlternateName_msginit = {
+  NULL,
+  &envoy_admin_v3_SubjectAlternateName__fields[0],
+  UPB_SIZE(12, 24), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
+};
+
+static const upb_MiniTable *messages_layout[5] = {
+  &envoy_admin_v3_Certificates_msginit,
+  &envoy_admin_v3_Certificate_msginit,
+  &envoy_admin_v3_CertificateDetails_msginit,
+  &envoy_admin_v3_CertificateDetails_OcspDetails_msginit,
+  &envoy_admin_v3_SubjectAlternateName_msginit,
+};
+
+const upb_MiniTable_File envoy_admin_v3_certs_proto_upb_file_layout = {
+  messages_layout,
+  NULL,
+  NULL,
+  5,
+  0,
+  0,
+};
+
+#include "upb/port_undef.inc"
+