grpc 1.59.5 → 1.60.0.pre1

data/include/grpc/grpc_security.h

@@ -818,20 +818,18 @@ GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void);
 /**
  * EXPERIMENTAL API - Subject to change
  *
- * Sets the minimum TLS version that will be negotiated during the TLS
- * handshake. If not set, the underlying SSL library will set it to TLS v1.2.
+ * Copies a grpc_tls_credentials_options.
  */
-GRPCAPI void grpc_tls_credentials_options_set_min_tls_version(
-    grpc_tls_credentials_options* options, grpc_tls_version min_tls_version);
+GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_copy(
+    grpc_tls_credentials_options* options);
 
 /**
  * EXPERIMENTAL API - Subject to change
  *
- * Sets the maximum TLS version that will be negotiated during the TLS
- * handshake. If not set, the underlying SSL library will set it to TLS v1.3.
+ * Destroys a grpc_tls_credentials_options.
  */
-GRPCAPI void grpc_tls_credentials_options_set_max_tls_version(
-    grpc_tls_credentials_options* options, grpc_tls_version max_tls_version);
+GRPCAPI void grpc_tls_credentials_options_destroy(
+    grpc_tls_credentials_options* options);
 
 /**
  * EXPERIMENTAL API - Subject to change

data/include/grpc/impl/channel_arg_names.h

@@ -328,6 +328,16 @@
 /** Channel arg to set http proxy per channel. If set, the channel arg
  *  value will be preferred over the environment variable settings. */
 #define GRPC_ARG_HTTP_PROXY "grpc.http_proxy"
+/** Specifies an HTTP proxy to use for individual addresses.
+ *  The proxy must be specified as an IP address, not a DNS name.
+ *  If set, the channel arg value will be preferred over the environment
+ *  variable settings. */
+#define GRPC_ARG_ADDRESS_HTTP_PROXY "grpc.address_http_proxy"
+/** Comma separated list of addresses or address ranges that are behind the
+ *  address HTTP proxy.
+ */
+#define GRPC_ARG_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES \
+  "grpc.address_http_proxy_enabled_addresses"
 /** If set to non zero, surfaces the user agent string to the server. User
     agent is surfaced by default. */
 #define GRPC_ARG_SURFACE_USER_AGENT "grpc.surface_user_agent"
@@ -370,6 +380,10 @@
 /** Configure the Differentiated Services Code Point used on outgoing packets.
  *  Integer value ranging from 0 to 63. */
 #define GRPC_ARG_DSCP "grpc.dscp"
+/** Connection Attempt Delay for use in Happy Eyeballs, in milliseconds.
+ *  Defaults to 250ms. */
+#define GRPC_ARG_HAPPY_EYEBALLS_CONNECTION_ATTEMPT_DELAY_MS \
+  "grpc.happy_eyeballs_connection_attempt_delay_ms"
 /** \} */
 
 #endif /* GRPC_IMPL_CHANNEL_ARG_NAMES_H */

data/src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -17,7 +17,6 @@
 #include "src/core/ext/filters/backend_metrics/backend_metric_filter.h"
 
 #include <inttypes.h>
-#include <limits.h>
 #include <stddef.h>
 
 #include <functional>
@@ -35,7 +34,6 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -151,14 +149,9 @@ ArenaPromise<ServerMetadataHandle> BackendMetricFilter::MakeCallPromise(
 }
 
 void RegisterBackendMetricFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterStage(
-      GRPC_SERVER_CHANNEL, INT_MAX, [](ChannelStackBuilder* builder) {
-        if (builder->channel_args().Contains(
-                GRPC_ARG_SERVER_CALL_METRIC_RECORDING)) {
-          builder->PrependFilter(&BackendMetricFilter::kFilter);
-        }
-        return true;
-      });
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_CHANNEL, &BackendMetricFilter::kFilter)
+      .IfHasChannelArg(GRPC_ARG_SERVER_CALL_METRIC_RECORDING);
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/channel_idle/channel_idle_filter.cc

@@ -19,12 +19,11 @@
 
 #include "src/core/ext/filters/channel_idle/channel_idle_filter.h"
 
-#include <stdint.h>
-
 #include <functional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/types/optional.h"
 
@@ -32,7 +31,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -52,17 +50,20 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/http2_errors.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
 namespace {
 
-// TODO(ctiller): The idle filter was disabled in client channel by default
-// due to b/143502997. Now the bug is fixed enable the filter by default.
-const auto kDefaultIdleTimeout = Duration::Infinity();
+// TODO(roth): This can go back to being a constant when the experiment
+// is removed.
+Duration DefaultIdleTimeout() {
+  if (IsClientIdlenessEnabled()) return Duration::Minutes(30);
+  return Duration::Infinity();
+}
 
 // If these settings change, make sure that we are not sending a GOAWAY for
 // inproc transport, since a GOAWAY to inproc ends up destroying the transport.
@@ -85,7 +86,7 @@ namespace {
 
 Duration GetClientIdleTimeout(const ChannelArgs& args) {
   return args.GetDurationFromIntMillis(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS)
-      .value_or(kDefaultIdleTimeout);
+      .value_or(DefaultIdleTimeout());
 }
 
 }  // namespace
@@ -127,8 +128,7 @@ struct MaxAgeFilter::Config {
         1.0 - kMaxConnectionAgeJitter, 1.0 + kMaxConnectionAgeJitter);
     // GRPC_MILLIS_INF_FUTURE - 0.5 converts the value to float, so that result
     // will not be cast to int implicitly before the comparison.
-    return Config{args_max_age * multiplier,
-                  args_max_idle * (IsJitterMaxIdleEnabled() ? multiplier : 1.0),
+    return Config{args_max_age * multiplier, args_max_idle * multiplier,
                   args_max_age_grace};
   }
 };
@@ -298,25 +298,17 @@ const grpc_channel_filter MaxAgeFilter::kFilter =
     MakePromiseBasedFilter<MaxAgeFilter, FilterEndpoint::kServer>("max_age");
 
 void RegisterChannelIdleFilters(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterStage(
-      GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](ChannelStackBuilder* builder) {
-        auto channel_args = builder->channel_args();
-        if (!channel_args.WantMinimalStack() &&
-            GetClientIdleTimeout(channel_args) != Duration::Infinity()) {
-          builder->PrependFilter(&ClientIdleFilter::kFilter);
-        }
-        return true;
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_CHANNEL, &ClientIdleFilter::kFilter)
+      .ExcludeFromMinimalStack()
+      .If([](const ChannelArgs& channel_args) {
+        return GetClientIdleTimeout(channel_args) != Duration::Infinity();
       });
-  builder->channel_init()->RegisterStage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](ChannelStackBuilder* builder) {
-        auto channel_args = builder->channel_args();
-        if (!channel_args.WantMinimalStack() &&
-            MaxAgeFilter::Config::FromChannelArgs(channel_args).enable()) {
-          builder->PrependFilter(&MaxAgeFilter::kFilter);
-        }
-        return true;
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_CHANNEL, &MaxAgeFilter::kFilter)
+      .ExcludeFromMinimalStack()
+      .If([](const ChannelArgs& channel_args) {
+        return MaxAgeFilter::Config::FromChannelArgs(channel_args).enable();
       });
 }
 

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

@@ -82,6 +82,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
@@ -93,8 +94,8 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver_registry.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
 #include "src/core/lib/service_config/service_config_impl.h"
@@ -1082,15 +1083,16 @@ class ClientChannel::ClientChannelControlHelper
   }
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
-      ServerAddress address, const ChannelArgs& args) override
+      const grpc_resolved_address& address, const ChannelArgs& per_address_args,
+      const ChannelArgs& args) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return nullptr;  // Shutting down.
     ChannelArgs subchannel_args = ClientChannel::MakeSubchannelArgs(
-        args, address.args(), chand_->subchannel_pool_,
+        args, per_address_args, chand_->subchannel_pool_,
         chand_->default_authority_);
     // Create subchannel.
     RefCountedPtr<Subchannel> subchannel =
-        chand_->client_channel_factory_->CreateSubchannel(address.address(),
+        chand_->client_channel_factory_->CreateSubchannel(address,
                                                           subchannel_args);
     if (subchannel == nullptr) return nullptr;
     // Make sure the subchannel has updated keepalive time.
@@ -1210,7 +1212,9 @@ RefCountedPtr<SubchannelPoolInterface> GetSubchannelPool(
 ClientChannel::ClientChannel(grpc_channel_element_args* args,
                              grpc_error_handle* error)
     : channel_args_(args->channel_args),
-      deadline_checking_enabled_(grpc_deadline_checking_enabled(channel_args_)),
+      deadline_checking_enabled_(
+          channel_args_.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
+              .value_or(!channel_args_.WantMinimalStack())),
       owning_stack_(args->channel_stack),
       client_channel_factory_(channel_args_.GetObject<ClientChannelFactory>()),
       channelz_node_(channel_args_.GetObject<channelz::ChannelNode>()),
@@ -2668,7 +2672,7 @@ ServiceConfigCallData::CallAttributeInterface*
 ClientChannel::LoadBalancedCall::LbCallState::GetCallAttribute(
     UniqueTypeName type) const {
   auto* service_config_call_data =
-      GetServiceConfigCallData(lb_call_->call_context());
+      GetServiceConfigCallData(lb_call_->call_context_);
   return service_config_call_data->GetCallAttribute(type);
 }
 
@@ -2723,14 +2727,13 @@ class ClientChannel::LoadBalancedCall::BackendMetricAccessor
 
 namespace {
 
-ClientCallTracer::CallAttemptTracer* CreateCallAttemptTracer(
-    grpc_call_context_element* context, bool is_transparent_retry) {
+void CreateCallAttemptTracer(grpc_call_context_element* context,
+                             bool is_transparent_retry) {
   auto* call_tracer = static_cast<ClientCallTracer*>(
       context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
-  if (call_tracer == nullptr) return nullptr;
+  if (call_tracer == nullptr) return;
   auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);
   context[GRPC_CONTEXT_CALL_TRACER].value = tracer;
-  return tracer;
 }
 
 }  // namespace
@@ -2743,7 +2746,8 @@ ClientChannel::LoadBalancedCall::LoadBalancedCall(
               ? "LoadBalancedCall"
               : nullptr),
       chand_(chand),
-      on_commit_(std::move(on_commit)) {
+      on_commit_(std::move(on_commit)),
+      call_context_(call_context) {
   CreateCallAttemptTracer(call_context, is_transparent_retry);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
     gpr_log(GPR_INFO, "chand=%p lb_call=%p: created", chand_, this);
@@ -3005,7 +3009,6 @@ ClientChannel::FilterBasedLoadBalancedCall::FilterBasedLoadBalancedCall(
                        is_transparent_retry),
       deadline_(args.deadline),
       arena_(args.arena),
-      call_context_(args.context),
       owning_call_(args.call_stack),
       call_combiner_(args.call_combiner),
       pollent_(pollent),
@@ -3442,7 +3445,7 @@ void ClientChannel::FilterBasedLoadBalancedCall::CreateSubchannelCall() {
       deadline_, arena_,
       // TODO(roth): When we implement hedging support, we will probably
       // need to use a separate call context for each subchannel call.
-      call_context_, call_combiner_};
+      call_context(), call_combiner_};
   grpc_error_handle error;
   subchannel_call_ = SubchannelCall::Create(std::move(call_args), &error);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
@@ -3491,12 +3494,14 @@ ClientChannel::PromiseBasedLoadBalancedCall::MakeCallPromise(
   }
   // Extract peer name from server initial metadata.
   call_args.server_initial_metadata->InterceptAndMap(
-      [this](ServerMetadataHandle metadata) {
-        if (call_attempt_tracer() != nullptr) {
-          call_attempt_tracer()->RecordReceivedInitialMetadata(metadata.get());
+      [self = RefCountedPtr<PromiseBasedLoadBalancedCall>(lb_call->Ref())](
+          ServerMetadataHandle metadata) {
+        if (self->call_attempt_tracer() != nullptr) {
+          self->call_attempt_tracer()->RecordReceivedInitialMetadata(
+              metadata.get());
         }
         Slice* peer_string = metadata->get_pointer(PeerString());
-        if (peer_string != nullptr) peer_string_ = peer_string->Ref();
+        if (peer_string != nullptr) self->peer_string_ = peer_string->Ref();
         return metadata;
       });
   client_initial_metadata_ = std::move(call_args.client_initial_metadata);
@@ -3587,11 +3592,6 @@ Arena* ClientChannel::PromiseBasedLoadBalancedCall::arena() const {
   return GetContext<Arena>();
 }
 
-grpc_call_context_element*
-ClientChannel::PromiseBasedLoadBalancedCall::call_context() const {
-  return GetContext<grpc_call_context_element>();
-}
-
 grpc_metadata_batch*
 ClientChannel::PromiseBasedLoadBalancedCall::send_initial_metadata() const {
   return client_initial_metadata_.get();

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

@@ -407,7 +407,7 @@ class ClientChannel::LoadBalancedCall
   ClientChannel* chand() const { return chand_; }
   ClientCallTracer::CallAttemptTracer* call_attempt_tracer() const {
     return static_cast<ClientCallTracer::CallAttemptTracer*>(
-        call_context()[GRPC_CONTEXT_CALL_TRACER].value);
+        call_context_[GRPC_CONTEXT_CALL_TRACER].value);
   }
   ConnectedSubchannel* connected_subchannel() const {
     return connected_subchannel_.get();
@@ -441,13 +441,14 @@ class ClientChannel::LoadBalancedCall
 
   void RecordLatency();
 
+  grpc_call_context_element* call_context() const { return call_context_; }
+
  private:
   class LbCallState;
   class Metadata;
   class BackendMetricAccessor;
 
   virtual Arena* arena() const = 0;
-  virtual grpc_call_context_element* call_context() const = 0;
   virtual grpc_polling_entity* pollent() = 0;
   virtual grpc_metadata_batch* send_initial_metadata() const = 0;
 
@@ -473,6 +474,7 @@ class ClientChannel::LoadBalancedCall
   const BackendMetricData* backend_metric_data_ = nullptr;
   std::unique_ptr<LoadBalancingPolicy::SubchannelCallTrackerInterface>
       lb_subchannel_call_tracker_;
+  grpc_call_context_element* const call_context_;
 };
 
 class ClientChannel::FilterBasedLoadBalancedCall
@@ -509,9 +511,6 @@ class ClientChannel::FilterBasedLoadBalancedCall
   using LoadBalancedCall::Commit;
 
   Arena* arena() const override { return arena_; }
-  grpc_call_context_element* call_context() const override {
-    return call_context_;
-  }
   grpc_polling_entity* pollent() override { return pollent_; }
   grpc_metadata_batch* send_initial_metadata() const override {
     return pending_batches_[0]
@@ -568,7 +567,6 @@ class ClientChannel::FilterBasedLoadBalancedCall
   // context.  This will save per-call memory overhead.
   Timestamp deadline_;
   Arena* arena_;
-  grpc_call_context_element* call_context_;
   grpc_call_stack* owning_call_;
   CallCombiner* call_combiner_;
   grpc_polling_entity* pollent_;
@@ -618,7 +616,6 @@ class ClientChannel::PromiseBasedLoadBalancedCall
 
  private:
   Arena* arena() const override;
-  grpc_call_context_element* call_context() const override;
   grpc_polling_entity* pollent() override { return &pollent_; }
   grpc_metadata_batch* send_initial_metadata() const override;
 

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

@@ -26,9 +26,7 @@
 #include "src/core/ext/filters/client_channel/client_channel_service_config.h"
 #include "src/core/ext/filters/client_channel/retry_service_config.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
 namespace grpc_core {
@@ -42,15 +40,16 @@ bool IsEverythingBelowClientChannelPromiseSafe(const ChannelArgs& args) {
 void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder) {
   internal::ClientChannelServiceConfigParser::Register(builder);
   internal::RetryServiceConfigParser::Register(builder);
-  builder->channel_init()->RegisterStage(
-      GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](ChannelStackBuilder* builder) {
-        builder->AppendFilter(
-            IsEverythingBelowClientChannelPromiseSafe(builder->channel_args())
-                ? &ClientChannel::kFilterVtableWithPromises
-                : &ClientChannel::kFilterVtableWithoutPromises);
-        return true;
-      });
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_CHANNEL,
+                       &ClientChannel::kFilterVtableWithPromises)
+      .If(IsEverythingBelowClientChannelPromiseSafe)
+      .Terminal();
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_CHANNEL,
+                       &ClientChannel::kFilterVtableWithoutPromises)
+      .IfNot(IsEverythingBelowClientChannelPromiseSafe)
+      .Terminal();
 }
 
 }  // namespace grpc_core

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

@@ -29,7 +29,6 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/transport.h"
-#include "src/core/lib/transport/transport_fwd.h"
 
 namespace grpc_core {
 
@@ -51,7 +50,7 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
 
   struct Result {
     // The connected transport.
-    grpc_transport* transport = nullptr;
+    Transport* transport = nullptr;
     // Channel args to be passed to filters.
     ChannelArgs channel_args;
     // Channelz socket node of the connected transport, if any.
@@ -59,7 +58,7 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
 
     void Reset() {
       if (transport != nullptr) {
-        grpc_transport_destroy(transport);
+        transport->Orphan();
         transport = nullptr;
       }
       channel_args = ChannelArgs();

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

@@ -21,7 +21,6 @@
 #include <stddef.h>
 
 #include <new>
-#include <string>
 #include <utility>
 
 #include "absl/status/statusor.h"

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

@@ -26,7 +26,6 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -58,15 +57,10 @@
 namespace grpc_core {
 namespace {
 
-bool ServerInCIDRRange(absl::string_view server_host,
-                       absl::string_view no_proxy_entry) {
-  auto server_address = StringToSockaddr(server_host, 0);
-  if (!server_address.ok()) {
-    return false;
-  }
+bool ServerInCIDRRange(const grpc_resolved_address& server_address,
+                       absl::string_view cidr_range) {
   std::pair<absl::string_view, absl::string_view> possible_cidr =
-      absl::StrSplit(no_proxy_entry, absl::MaxSplits('/', 2),
-                     absl::SkipEmpty());
+      absl::StrSplit(cidr_range, absl::MaxSplits('/', 1), absl::SkipEmpty());
   if (possible_cidr.first.empty() || possible_cidr.second.empty()) {
     return false;
   }
@@ -77,12 +71,34 @@ bool ServerInCIDRRange(absl::string_view server_host,
   uint32_t mask_bits = 0;
   if (absl::SimpleAtoi(possible_cidr.second, &mask_bits)) {
     grpc_sockaddr_mask_bits(&*proxy_address, mask_bits);
-    return grpc_sockaddr_match_subnet(&*server_address, &*proxy_address,
+    return grpc_sockaddr_match_subnet(&server_address, &*proxy_address,
                                       mask_bits);
   }
   return false;
 }
 
+bool ExactMatchOrSubdomain(absl::string_view host_name,
+                           absl::string_view host_name_or_domain) {
+  return absl::EndsWithIgnoreCase(host_name, host_name_or_domain);
+}
+
+// Parses the list of host names, addresses or subnet masks and returns true if
+// the target address or host matches any value.
+bool AddressIncluded(
+    const absl::optional<grpc_resolved_address>& target_address,
+    absl::string_view host_name, absl::string_view addresses_and_subnets) {
+  for (absl::string_view entry :
+       absl::StrSplit(addresses_and_subnets, ',', absl::SkipEmpty())) {
+    absl::string_view sanitized_entry = absl::StripAsciiWhitespace(entry);
+    if (ExactMatchOrSubdomain(host_name, sanitized_entry) ||
+        (target_address.has_value() &&
+         ServerInCIDRRange(*target_address, sanitized_entry))) {
+      return true;
+    }
+  }
+  return false;
+}
+
 ///
 /// Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
 /// proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
@@ -157,6 +173,33 @@ std::string MaybeAddDefaultPort(absl::string_view target) {
   return std::string(target);
 }
 
+absl::optional<std::string> GetChannelArgOrEnvVarValue(
+    const ChannelArgs& args, absl::string_view channel_arg,
+    const char* env_var) {
+  auto arg_value = args.GetOwnedString(channel_arg);
+  if (arg_value.has_value()) {
+    return arg_value;
+  }
+  return GetEnv(env_var);
+}
+
+absl::optional<grpc_resolved_address> GetAddressProxyServer(
+    const ChannelArgs& args) {
+  auto address_value = GetChannelArgOrEnvVarValue(
+      args, GRPC_ARG_ADDRESS_HTTP_PROXY, HttpProxyMapper::kAddressProxyEnvVar);
+  if (!address_value.has_value()) {
+    return absl::nullopt;
+  }
+  auto address = StringToSockaddr(*address_value);
+  if (!address.ok()) {
+    gpr_log(GPR_ERROR, "cannot parse value of '%s' env var. Error: %s",
+            HttpProxyMapper::kAddressProxyEnvVar,
+            address.status().ToString().c_str());
+    return absl::nullopt;
+  }
+  return *address;
+}
+
 }  // namespace
 
 absl::optional<std::string> HttpProxyMapper::MapName(
@@ -191,7 +234,6 @@ absl::optional<std::string> HttpProxyMapper::MapName(
     no_proxy_str = GetEnv("no_proxy");
   }
   if (no_proxy_str.has_value()) {
-    bool use_proxy = true;
     std::string server_host;
     std::string server_port;
     if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
@@ -201,19 +243,15 @@ absl::optional<std::string> HttpProxyMapper::MapName(
               "host '%s'",
               std::string(server_uri).c_str());
     } else {
-      std::vector<absl::string_view> no_proxy_hosts =
-          absl::StrSplit(*no_proxy_str, ',', absl::SkipEmpty());
-      for (const auto& no_proxy_entry : no_proxy_hosts) {
-        auto entry = absl::StripAsciiWhitespace(no_proxy_entry);
-        if (absl::EndsWithIgnoreCase(server_host, entry) ||
-            ServerInCIDRRange(server_host, entry)) {
-          gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
-                  std::string(server_uri).c_str());
-          use_proxy = false;
-          break;
-        }
+      auto address = StringToSockaddr(server_host, 0);
+      if (AddressIncluded(address.ok()
+                              ? absl::optional<grpc_resolved_address>(*address)
+                              : absl::nullopt,
+                          server_host, *no_proxy_str)) {
+        gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
+                std::string(server_uri).c_str());
+        return absl::nullopt;
       }
-      if (!use_proxy) return absl::nullopt;
     }
   }
   *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER,
@@ -229,6 +267,35 @@ absl::optional<std::string> HttpProxyMapper::MapName(
   return name_to_resolve;
 }
 
+absl::optional<grpc_resolved_address> HttpProxyMapper::MapAddress(
+    const grpc_resolved_address& address, ChannelArgs* args) {
+  auto proxy_address = GetAddressProxyServer(*args);
+  if (!proxy_address.has_value()) {
+    return absl::nullopt;
+  }
+  auto address_string = grpc_sockaddr_to_string(&address, true);
+  if (!address_string.ok()) {
+    gpr_log(GPR_ERROR, "Unable to convert address to string: %s",
+            std::string(address_string.status().message()).c_str());
+    return absl::nullopt;
+  }
+  std::string host_name, port;
+  if (!SplitHostPort(*address_string, &host_name, &port)) {
+    gpr_log(GPR_ERROR, "Address %s cannot be split in host and port",
+            address_string->c_str());
+    return absl::nullopt;
+  }
+  auto enabled_addresses = GetChannelArgOrEnvVarValue(
+      *args, GRPC_ARG_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES,
+      kAddressProxyEnabledAddressesEnvVar);
+  if (!enabled_addresses.has_value() ||
+      !AddressIncluded(address, host_name, *enabled_addresses)) {
+    return absl::nullopt;
+  }
+  *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER, *address_string);
+  return proxy_address;
+}
+
 void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder) {
   builder->proxy_mapper_registry()->Register(
       true /* at_start */,

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

@@ -35,14 +35,15 @@ namespace grpc_core {
 
 class HttpProxyMapper : public ProxyMapperInterface {
  public:
+  static constexpr char const* kAddressProxyEnvVar = "GRPC_ADDRESS_HTTP_PROXY";
+  static constexpr char const* kAddressProxyEnabledAddressesEnvVar =
+      "GRPC_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES";
+
   absl::optional<std::string> MapName(absl::string_view server_uri,
                                       ChannelArgs* args) override;
 
   absl::optional<grpc_resolved_address> MapAddress(
-      const grpc_resolved_address& /*address*/,
-      ChannelArgs* /*args*/) override {
-    return absl::nullopt;
-  }
+      const grpc_resolved_address& address, ChannelArgs* args) override;
 };
 
 void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);