grpc 1.42.0 → 1.45.0

data/include/grpc/grpc_security_constants.h

@@ -28,6 +28,7 @@ extern "C" {
 #define GRPC_TLS_TRANSPORT_SECURITY_TYPE "tls"
 
 #define GRPC_X509_CN_PROPERTY_NAME "x509_common_name"
+#define GRPC_X509_SUBJECT_PROPERTY_NAME "x509_subject"
 #define GRPC_X509_SAN_PROPERTY_NAME "x509_subject_alternative_name"
 #define GRPC_X509_PEM_CERT_PROPERTY_NAME "x509_pem_cert"
 // Please note that internally, we just faithfully pass whatever value we got by
@@ -135,20 +136,6 @@ typedef enum {
   GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY,
 } grpc_security_level;
 
-typedef enum {
-  /** Default option: performs server certificate verification and hostname
-     verification. */
-  GRPC_TLS_SERVER_VERIFICATION,
-  /** Performs server certificate verification, but skips hostname verification
-     Client is responsible for verifying server's identity via
-     server authorization check callback. */
-  GRPC_TLS_SKIP_HOSTNAME_VERIFICATION,
-  /** Skips both server certificate and hostname verification.
-     Client is responsible for verifying server's identity and
-     server's certificate via server authorization check callback. */
-  GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION
-} grpc_tls_server_verification_option;
-
 /**
  * Type of local connections for which local channel/server credentials will be
  * applied. It supports UDS and local TCP connections.

data/include/grpc/impl/codegen/compression_types.h

@@ -60,8 +60,6 @@ typedef enum {
   GRPC_COMPRESS_NONE = 0,
   GRPC_COMPRESS_DEFLATE,
   GRPC_COMPRESS_GZIP,
-  /* EXPERIMENTAL: Stream compression is currently experimental. */
-  GRPC_COMPRESS_STREAM_GZIP,
   /* TODO(ctiller): snappy */
   GRPC_COMPRESS_ALGORITHMS_COUNT
 } grpc_compression_algorithm;

data/include/grpc/impl/codegen/grpc_types.h

@@ -384,11 +384,10 @@ typedef struct {
     "latency". */
 #define GRPC_ARG_OPTIMIZATION_TARGET "grpc.optimization_target"
 /** Enables retry functionality.  Defaults to true.  When enabled,
-    configurable retries are enabled when they are configured via the
-    service config.  For details, see:
+    transparent retries will be performed as appropriate, and configurable
+    retries are enabled when they are configured via the service config.
+    For details, see:
       https://github.com/grpc/proposal/blob/master/A6-client-retries.md
-    NOTE: Transparent retries are not yet implemented.  When they are
-          implemented, they will also be enabled by this arg.
     NOTE: Hedging functionality is not yet implemented, so those
           fields in the service config will currently be ignored.  See
           also the GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING arg below.
@@ -422,10 +421,14 @@ typedef struct {
 /** If set, inhibits health checking (which may be enabled via the
  *  service config.) */
 #define GRPC_ARG_INHIBIT_HEALTH_CHECKING "grpc.inhibit_health_checking"
-/** If set, the channel's resolver is allowed to query for SRV records.
- * For example, this is useful as a way to enable the "grpclb"
- * load balancing policy. Note that this only works with the "ares"
- * DNS resolver, and isn't supported by the "native" DNS resolver. */
+/** If enabled, the channel's DNS resolver queries for SRV records.
+ *  This is useful only when using the "grpclb" load balancing policy,
+ *  as described in the following documents:
+ *   https://github.com/grpc/proposal/blob/master/A5-grpclb-in-dns.md
+ *   https://github.com/grpc/proposal/blob/master/A24-lb-policy-config.md
+ *   https://github.com/grpc/proposal/blob/master/A26-grpclb-selection.md
+ *  Note that this works only with the "ares" DNS resolver; it isn't supported
+ *  by the "native" DNS resolver. */
 #define GRPC_ARG_DNS_ENABLE_SRV_QUERIES "grpc.dns_enable_srv_queries"
 /** If set, determines an upper bound on the number of milliseconds that the
  * c-ares based DNS resolver will wait on queries before cancelling them.
@@ -445,6 +448,12 @@ typedef struct {
     gRPC authorization check. */
 #define GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER \
   "grpc.authorization_policy_provider"
+/** EXPERIMENTAL. Updates to a server's configuration from a config fetcher (for
+ * example, listener updates from xDS) cause all older connections to be
+ * gracefully shut down (i.e., "drained") with a grace period configured by this
+ * channel arg. Int valued, milliseconds. Defaults to 10 minutes.*/
+#define GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS \
+  "grpc.experimental.server_config_change_drain_grace_time_ms"
 /** \} */
 
 /** Result of a grpc call. If the caller satisfies the prerequisites of a

data/include/grpc/impl/codegen/port_platform.h

@@ -51,7 +51,9 @@
 /*
  * Defines GRPC_ERROR_IS_ABSEIL_STATUS to use absl::Status for grpc_error_handle
  */
+#ifndef GRPC_ERROR_IS_ABSEIL_STATUS
 // #define GRPC_ERROR_IS_ABSEIL_STATUS 1
+#endif
 
 /* Get windows.h included everywhere (we need it) */
 #if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32)
@@ -126,11 +128,13 @@
 #elif defined(ANDROID) || defined(__ANDROID__)
 #define GPR_PLATFORM_STRING "android"
 #define GPR_ANDROID 1
-#ifdef __ANDROID_API__
-#if (__ANDROID_API__) >= 29
-#define GPR_SUPPORT_BINDER_TRANSPORT 1
+#ifndef __ANDROID_API__
+#error "__ANDROID_API__ must be defined for Android builds."
 #endif
+#if __ANDROID_API__ < 21
+#error "Requires Android API v21 and above"
 #endif
+#define GPR_SUPPORT_BINDER_TRANSPORT 1
 // TODO(apolcyn): re-evaluate support for c-ares
 // on android after upgrading our c-ares dependency.
 // See https://github.com/grpc/grpc/issues/18038.

data/include/grpc/impl/codegen/slice.h

@@ -58,7 +58,10 @@ struct grpc_slice_refcount;
    Multiple grpc_slice values may share a ref count.
 
    If the slice does not have a refcount, it represents an inlined small piece
-   of data that is copied by value. */
+   of data that is copied by value.
+
+   As a special case, a slice can be given refcount == uintptr_t(1), meaning
+   that the slice represents external data that is not refcounted. */
 struct grpc_slice {
   struct grpc_slice_refcount* refcount;
   union grpc_slice_data {

data/include/grpc/slice.h

@@ -69,12 +69,6 @@ GPRAPI grpc_slice grpc_slice_malloc_large(size_t length);
 
 #define GRPC_SLICE_MALLOC(len) grpc_slice_malloc(len)
 
-/** Intern a slice:
-
-   The return value for two invocations of this function with  the same sequence
-   of bytes is a slice which points to the same memory. */
-GPRAPI grpc_slice grpc_slice_intern(grpc_slice slice);
-
 /** Create a slice by copying a string.
    Does not preserve null terminators.
    Equivalent to:
@@ -129,9 +123,6 @@ GPRAPI grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split);
 
 GPRAPI grpc_slice grpc_empty_slice(void);
 
-GPRAPI uint32_t grpc_slice_default_hash_impl(grpc_slice s);
-GPRAPI int grpc_slice_default_eq_impl(grpc_slice a, grpc_slice b);
-
 GPRAPI int grpc_slice_eq(grpc_slice a, grpc_slice b);
 
 /** Returns <0 if a < b, ==0 if a == b, >0 if a > b
@@ -151,8 +142,6 @@ GPRAPI int grpc_slice_chr(grpc_slice s, char c);
    if it's not found */
 GPRAPI int grpc_slice_slice(grpc_slice haystack, grpc_slice needle);
 
-GPRAPI uint32_t grpc_slice_hash(grpc_slice s);
-
 /** Do two slices point at the same memory, with the same length
    If a or b is inlined, actually compares data */
 GPRAPI int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b);

data/src/core/ext/filters/client_channel/backend_metric.cc

@@ -31,14 +31,14 @@ std::map<absl::string_view, double> ParseMap(
     xds_data_orca_v3_OrcaLoadReport* msg,
     const EntryType* (*entry_func)(const xds_data_orca_v3_OrcaLoadReport*,
                                    size_t*),
-    upb_strview (*key_func)(const EntryType*),
+    upb_StringView (*key_func)(const EntryType*),
     double (*value_func)(const EntryType*), Arena* arena) {
   std::map<absl::string_view, double> result;
-  size_t i = UPB_MAP_BEGIN;
+  size_t i = kUpb_Map_Begin;
   while (true) {
     const auto* entry = entry_func(msg, &i);
     if (entry == nullptr) break;
-    upb_strview key_view = key_func(entry);
+    upb_StringView key_view = key_func(entry);
     char* key = static_cast<char*>(arena->Alloc(key_view.size));
     memcpy(key, key_view.data, key_view.size);
     result[absl::string_view(key, key_view.size)] = value_func(entry);
@@ -48,16 +48,15 @@ std::map<absl::string_view, double> ParseMap(
 
 }  // namespace
 
-const LoadBalancingPolicy::BackendMetricData* ParseBackendMetricData(
-    const grpc_slice& serialized_load_report, Arena* arena) {
+const LoadBalancingPolicy::BackendMetricAccessor::BackendMetricData*
+ParseBackendMetricData(const Slice& serialized_load_report, Arena* arena) {
   upb::Arena upb_arena;
   xds_data_orca_v3_OrcaLoadReport* msg = xds_data_orca_v3_OrcaLoadReport_parse(
-      reinterpret_cast<const char*>(
-          GRPC_SLICE_START_PTR(serialized_load_report)),
-      GRPC_SLICE_LENGTH(serialized_load_report), upb_arena.ptr());
+      reinterpret_cast<const char*>(serialized_load_report.begin()),
+      serialized_load_report.size(), upb_arena.ptr());
   if (msg == nullptr) return nullptr;
-  LoadBalancingPolicy::BackendMetricData* backend_metric_data =
-      arena->New<LoadBalancingPolicy::BackendMetricData>();
+  auto* backend_metric_data = arena->New<
+      LoadBalancingPolicy::BackendMetricAccessor::BackendMetricData>();
   backend_metric_data->cpu_utilization =
       xds_data_orca_v3_OrcaLoadReport_cpu_utilization(msg);
   backend_metric_data->mem_utilization =

data/src/core/ext/filters/client_channel/backend_metric.h

@@ -22,14 +22,15 @@
 #include <grpc/slice.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy.h"
-#include "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice.h"
 
 namespace grpc_core {
 
 // Parses the serialized load report and allocates a BackendMetricData
 // object on the arena.
-const LoadBalancingPolicy::BackendMetricData* ParseBackendMetricData(
-    const grpc_slice& serialized_load_report, Arena* arena);
+const LoadBalancingPolicy::BackendMetricAccessor::BackendMetricData*
+ParseBackendMetricData(const Slice& serialized_load_report, Arena* arena);
 
 }  // namespace grpc_core
 

data/src/core/ext/filters/client_channel/backup_poller.cc

@@ -29,6 +29,7 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset.h"
@@ -57,7 +58,8 @@ static backup_poller* g_poller = nullptr;  // guarded by g_poller_mu
 // g_poll_interval_ms is set only once at the first time
 // grpc_client_channel_start_backup_polling() is called, after that it is
 // treated as const.
-static int g_poll_interval_ms = DEFAULT_POLL_INTERVAL_MS;
+static grpc_core::Duration g_poll_interval =
+    grpc_core::Duration::Milliseconds(DEFAULT_POLL_INTERVAL_MS);
 
 GPR_GLOBAL_CONFIG_DEFINE_INT32(
     grpc_client_channel_backup_poll_interval_ms, DEFAULT_POLL_INTERVAL_MS,
@@ -75,10 +77,10 @@ void grpc_client_channel_global_init_backup_polling() {
   if (poll_interval_ms < 0) {
     gpr_log(GPR_ERROR,
             "Invalid GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS: %d, "
-            "default value %d will be used.",
-            poll_interval_ms, g_poll_interval_ms);
+            "default value %" PRId64 " will be used.",
+            poll_interval_ms, g_poll_interval.millis());
   } else {
-    g_poll_interval_ms = poll_interval_ms;
+    g_poll_interval = grpc_core::Duration::Milliseconds(poll_interval_ms);
   }
 }
 
@@ -133,7 +135,7 @@ static void run_poller(void* arg, grpc_error_handle error) {
   gpr_mu_unlock(p->pollset_mu);
   GRPC_LOG_IF_ERROR("Run client channel backup poller", err);
   grpc_timer_init(&p->polling_timer,
-                  grpc_core::ExecCtx::Get()->Now() + g_poll_interval_ms,
+                  grpc_core::ExecCtx::Get()->Now() + g_poll_interval,
                   &p->run_poller_closure);
 }
 
@@ -150,14 +152,15 @@ static void g_poller_init_locked() {
     GRPC_CLOSURE_INIT(&g_poller->run_poller_closure, run_poller, g_poller,
                       grpc_schedule_on_exec_ctx);
     grpc_timer_init(&g_poller->polling_timer,
-                    grpc_core::ExecCtx::Get()->Now() + g_poll_interval_ms,
+                    grpc_core::ExecCtx::Get()->Now() + g_poll_interval,
                     &g_poller->run_poller_closure);
   }
 }
 
 void grpc_client_channel_start_backup_polling(
     grpc_pollset_set* interested_parties) {
-  if (g_poll_interval_ms == 0 || grpc_iomgr_run_in_background()) {
+  if (g_poll_interval == grpc_core::Duration::Zero() ||
+      grpc_iomgr_run_in_background()) {
     return;
   }
   gpr_mu_lock(&g_poller_mu);
@@ -175,7 +178,8 @@ void grpc_client_channel_start_backup_polling(
 
 void grpc_client_channel_stop_backup_polling(
     grpc_pollset_set* interested_parties) {
-  if (g_poll_interval_ms == 0 || grpc_iomgr_run_in_background()) {
+  if (g_poll_interval == grpc_core::Duration::Zero() ||
+      grpc_iomgr_run_in_background()) {
     return;
   }
   grpc_pollset_set_del_pollset(interested_parties, g_poller->pollset);

data/src/core/ext/filters/client_channel/channel_connectivity.cc

@@ -95,7 +95,7 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
       // watch, but we are hiding that fact from the application.
       if (IsLameChannel(channel)) {
         // Ref from object creation is held by timer callback.
-        StartTimer(grpc_timespec_to_millis_round_up(deadline));
+        StartTimer(Timestamp::FromTimespecRoundUp(deadline));
         return;
       }
       gpr_log(GPR_ERROR,
@@ -108,7 +108,7 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
     // the other by the watcher callback.
     Ref().release();
     auto* watcher_timer_init_state = new WatcherTimerInitState(
-        this, grpc_timespec_to_millis_round_up(deadline));
+        this, Timestamp::FromTimespecRoundUp(deadline));
     client_channel->AddExternalConnectivityWatcher(
         grpc_polling_entity_create_from_pollset(grpc_cq_pollset(cq)), &state_,
         &on_complete_, watcher_timer_init_state->closure());
@@ -123,7 +123,7 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
   // ClientChannel actually starts the watch.
   class WatcherTimerInitState {
    public:
-    WatcherTimerInitState(StateWatcher* state_watcher, grpc_millis deadline)
+    WatcherTimerInitState(StateWatcher* state_watcher, Timestamp deadline)
         : state_watcher_(state_watcher), deadline_(deadline) {
       GRPC_CLOSURE_INIT(&closure_, WatcherTimerInit, this, nullptr);
     }
@@ -138,11 +138,11 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
     }
 
     StateWatcher* state_watcher_;
-    grpc_millis deadline_;
+    Timestamp deadline_;
     grpc_closure closure_;
   };
 
-  void StartTimer(grpc_millis deadline) {
+  void StartTimer(Timestamp deadline) {
     grpc_timer_init(&timer_, deadline, &on_timeout_);
   }