grpc 1.40.0 → 1.46.3

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

@@ -1,176 +1,41 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
 
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
-#include <grpc/support/sync.h>
+#include <string>
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/gprpp/arena.h"
-#include "src/core/lib/gprpp/atomic.h"
+#include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/call_combiner.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/transport/byte_stream.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
-class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
- public:
-  HealthCheckClient(std::string service_name,
-                    RefCountedPtr<ConnectedSubchannel> connected_subchannel,
-                    grpc_pollset_set* interested_parties,
-                    RefCountedPtr<channelz::SubchannelNode> channelz_node,
-                    RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
-
-  ~HealthCheckClient() override;
-
-  void Orphan() override;
-
- private:
-  // Contains a call to the backend and all the data related to the call.
-  class CallState : public Orphanable {
-   public:
-    CallState(RefCountedPtr<HealthCheckClient> health_check_client,
-              grpc_pollset_set* interested_parties_);
-    ~CallState() override;
-
-    void Orphan() override;
-
-    void StartCall() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&HealthCheckClient::mu_);
-
-   private:
-    void Cancel();
-
-    void StartBatch(grpc_transport_stream_op_batch* batch);
-    static void StartBatchInCallCombiner(void* arg, grpc_error_handle error);
-
-    void CallEndedLocked(bool retry)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(health_check_client_->mu_);
-
-    static void OnComplete(void* arg, grpc_error_handle error);
-    static void RecvInitialMetadataReady(void* arg, grpc_error_handle error);
-    static void RecvMessageReady(void* arg, grpc_error_handle error);
-    static void RecvTrailingMetadataReady(void* arg, grpc_error_handle error);
-    static void StartCancel(void* arg, grpc_error_handle error);
-    static void OnCancelComplete(void* arg, grpc_error_handle error);
-
-    static void OnByteStreamNext(void* arg, grpc_error_handle error);
-    void ContinueReadingRecvMessage();
-    grpc_error_handle PullSliceFromRecvMessage();
-    void DoneReadingRecvMessage(grpc_error_handle error);
-
-    static void AfterCallStackDestruction(void* arg, grpc_error_handle error);
-
-    RefCountedPtr<HealthCheckClient> health_check_client_;
-    grpc_polling_entity pollent_;
-
-    Arena* arena_;
-    grpc_core::CallCombiner call_combiner_;
-    grpc_call_context_element context_[GRPC_CONTEXT_COUNT] = {};
-
-    // The streaming call to the backend. Always non-null.
-    // Refs are tracked manually; when the last ref is released, the
-    // CallState object will be automatically destroyed.
-    SubchannelCall* call_;
-
-    grpc_transport_stream_op_batch_payload payload_;
-    grpc_transport_stream_op_batch batch_;
-    grpc_transport_stream_op_batch recv_message_batch_;
-    grpc_transport_stream_op_batch recv_trailing_metadata_batch_;
-
-    grpc_closure on_complete_;
-
-    // send_initial_metadata
-    grpc_metadata_batch send_initial_metadata_;
-    grpc_linked_mdelem path_metadata_storage_;
-
-    // send_message
-    ManualConstructor<SliceBufferByteStream> send_message_;
-
-    // send_trailing_metadata
-    grpc_metadata_batch send_trailing_metadata_;
-
-    // recv_initial_metadata
-    grpc_metadata_batch recv_initial_metadata_;
-    grpc_closure recv_initial_metadata_ready_;
-
-    // recv_message
-    OrphanablePtr<ByteStream> recv_message_;
-    grpc_closure recv_message_ready_;
-    grpc_slice_buffer recv_message_buffer_;
-    Atomic<bool> seen_response_{false};
-
-    // True if the cancel_stream batch has been started.
-    Atomic<bool> cancelled_{false};
-
-    // recv_trailing_metadata
-    grpc_metadata_batch recv_trailing_metadata_;
-    grpc_transport_stream_stats collect_stats_;
-    grpc_closure recv_trailing_metadata_ready_;
-
-    // Closure for call stack destruction.
-    grpc_closure after_call_stack_destruction_;
-  };
-
-  void StartCall();
-  void StartCallLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  void StartRetryTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnRetryTimer(void* arg, grpc_error_handle error);
-
-  void SetHealthStatus(grpc_connectivity_state state, const char* reason);
-  void SetHealthStatusLocked(grpc_connectivity_state state, const char* reason)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  std::string service_name_;
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
-  grpc_pollset_set* interested_parties_;  // Do not own.
-  RefCountedPtr<channelz::SubchannelNode> channelz_node_;
-
-  Mutex mu_;
-  RefCountedPtr<ConnectivityStateWatcherInterface> watcher_
-      ABSL_GUARDED_BY(mu_);
-  bool shutting_down_ ABSL_GUARDED_BY(mu_) = false;
-
-  // The data associated with the current health check call.  It holds a ref
-  // to this HealthCheckClient object.
-  OrphanablePtr<CallState> call_state_ ABSL_GUARDED_BY(mu_);
-
-  // Call retry state.
-  BackOff retry_backoff_ ABSL_GUARDED_BY(mu_);
-  grpc_timer retry_timer_ ABSL_GUARDED_BY(mu_);
-  grpc_closure retry_timer_callback_ ABSL_GUARDED_BY(mu_);
-  bool retry_timer_callback_pending_ ABSL_GUARDED_BY(mu_) = false;
-};
+OrphanablePtr<SubchannelStreamClient> MakeHealthCheckClient(
+    std::string service_name,
+    RefCountedPtr<ConnectedSubchannel> connected_subchannel,
+    grpc_pollset_set* interested_parties,
+    RefCountedPtr<channelz::SubchannelNode> channelz_node,
+    RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H

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

@@ -30,13 +30,15 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/handshaker.h"
 #include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/http/format_request.h"
 #include "src/core/lib/http/parser.h"
+#include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -137,12 +139,11 @@ void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
 void HttpConnectHandshaker::OnWriteDoneScheduler(void* arg,
                                                  grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-  grpc_core::ExecCtx::Run(
-      DEBUG_LOCATION,
-      GRPC_CLOSURE_INIT(&handshaker->request_done_closure_,
-                        &HttpConnectHandshaker::OnWriteDone, handshaker,
-                        grpc_schedule_on_exec_ctx),
-      GRPC_ERROR_REF(error));
+  ExecCtx::Run(DEBUG_LOCATION,
+               GRPC_CLOSURE_INIT(&handshaker->request_done_closure_,
+                                 &HttpConnectHandshaker::OnWriteDone,
+                                 handshaker, grpc_schedule_on_exec_ctx),
+               GRPC_ERROR_REF(error));
 }
 
 // Callback invoked when finished writing HTTP CONNECT request.
@@ -172,12 +173,11 @@ void HttpConnectHandshaker::OnWriteDone(void* arg, grpc_error_handle error) {
 void HttpConnectHandshaker::OnReadDoneScheduler(void* arg,
                                                 grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-  grpc_core::ExecCtx::Run(
-      DEBUG_LOCATION,
-      GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
-                        &HttpConnectHandshaker::OnReadDone, handshaker,
-                        grpc_schedule_on_exec_ctx),
-      GRPC_ERROR_REF(error));
+  ExecCtx::Run(DEBUG_LOCATION,
+               GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
+                                 &HttpConnectHandshaker::OnReadDone, handshaker,
+                                 grpc_schedule_on_exec_ctx),
+               GRPC_ERROR_REF(error));
 }
 
 // Callback invoked for reading HTTP CONNECT response.
@@ -246,10 +246,9 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
   // Make sure we got a 2xx response.
   if (handshaker->http_response_.status < 200 ||
       handshaker->http_response_.status >= 300) {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+    error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrCat("HTTP proxy returned response code ",
-                     handshaker->http_response_.status)
-            .c_str());
+                     handshaker->http_response_.status));
     handshaker->HandshakeFailedLocked(error);
     goto done;
   }
@@ -332,18 +331,15 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   gpr_log(GPR_INFO, "Connecting to server %s via HTTP proxy %s", server_name,
           proxy_name.c_str());
   // Construct HTTP CONNECT request.
-  grpc_httpcli_request request;
-  request.host = server_name;
-  request.ssl_host_override = nullptr;
-  request.http.method = const_cast<char*>("CONNECT");
-  request.http.path = server_name;
-  request.http.version = GRPC_HTTP_HTTP10;  // Set by OnReadDone
-  request.http.hdrs = headers;
-  request.http.hdr_count = num_headers;
-  request.http.body_length = 0;
-  request.http.body = nullptr;
-  request.handshaker = &grpc_httpcli_plaintext;
-  grpc_slice request_slice = grpc_httpcli_format_connect_request(&request);
+  grpc_http_request request;
+  request.method = const_cast<char*>("CONNECT");
+  request.version = GRPC_HTTP_HTTP10;  // Set by OnReadDone
+  request.hdrs = headers;
+  request.hdr_count = num_headers;
+  request.body_length = 0;
+  request.body = nullptr;
+  grpc_slice request_slice =
+      grpc_httpcli_format_connect_request(&request, server_name, server_name);
   grpc_slice_buffer_add(&write_buffer_, request_slice);
   // Clean up.
   gpr_free(headers);
@@ -382,10 +378,10 @@ class HttpConnectHandshakerFactory : public HandshakerFactory {
 
 }  // namespace
 
-}  // namespace grpc_core
-
-void grpc_http_connect_register_handshaker_factory() {
-  grpc_core::HandshakerRegistry::RegisterHandshakerFactory(
-      true /* at_start */, grpc_core::HANDSHAKER_CLIENT,
-      absl::make_unique<grpc_core::HttpConnectHandshakerFactory>());
+void RegisterHttpConnectHandshaker(CoreConfiguration::Builder* builder) {
+  builder->handshaker_registry()->RegisterHandshakerFactory(
+      true /* at_start */, HANDSHAKER_CLIENT,
+      absl::make_unique<HttpConnectHandshakerFactory>());
 }
+
+}  // namespace grpc_core

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

@@ -19,6 +19,10 @@
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_CONNECT_HANDSHAKER_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_CONNECT_HANDSHAKER_H
 
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
 /// Channel arg indicating the server in HTTP CONNECT request (string).
 /// The presence of this arg triggers the use of HTTP CONNECT.
 #define GRPC_ARG_HTTP_CONNECT_SERVER "grpc.http_connect_server"
@@ -28,7 +32,11 @@
 /// separated by colons.
 #define GRPC_ARG_HTTP_CONNECT_HEADERS "grpc.http_connect_headers"
 
-/// Registers handshaker factory.
-void grpc_http_connect_register_handshaker_factory();
+namespace grpc_core {
+
+// Register the HTTP Connect handshaker into the configuration builder.
+void RegisterHttpConnectHandshaker(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_CONNECT_HANDSHAKER_H */

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

@@ -23,7 +23,9 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/strip.h"
 
 #include <grpc/support/alloc.h>
@@ -64,24 +66,24 @@ char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
    * 4. http_proxy environment variable
    * If none of the above are set, then no HTTP proxy will be used.
    */
-  char* uri_str =
-      gpr_strdup(grpc_channel_args_find_string(args, GRPC_ARG_HTTP_PROXY));
-  if (uri_str == nullptr) uri_str = gpr_getenv("grpc_proxy");
-  if (uri_str == nullptr) uri_str = gpr_getenv("https_proxy");
-  if (uri_str == nullptr) uri_str = gpr_getenv("http_proxy");
+  auto uri_str = UniquePtr<char>(
+      gpr_strdup(grpc_channel_args_find_string(args, GRPC_ARG_HTTP_PROXY)));
+  if (uri_str == nullptr) uri_str = UniquePtr<char>(gpr_getenv("grpc_proxy"));
+  if (uri_str == nullptr) uri_str = UniquePtr<char>(gpr_getenv("https_proxy"));
+  if (uri_str == nullptr) uri_str = UniquePtr<char>(gpr_getenv("http_proxy"));
   if (uri_str == nullptr) return nullptr;
   // an emtpy value means "don't use proxy"
-  if (uri_str[0] == '\0') goto done;
-  uri = URI::Parse(uri_str);
+  if (uri_str.get()[0] == '\0') return nullptr;
+  uri = URI::Parse(uri_str.get());
   if (!uri.ok() || uri->authority().empty()) {
     gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var. Error: %s",
             uri.status().ToString().c_str());
-    goto done;
+    return nullptr;
   }
   if (uri->scheme() != "http") {
     gpr_log(GPR_ERROR, "'%s' scheme not supported in proxy URI",
             uri->scheme().c_str());
-    goto done;
+    return nullptr;
   }
   /* Split on '@' to separate user credentials from host */
   gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
@@ -103,8 +105,6 @@ char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
     proxy_name = nullptr;
   }
   gpr_free(authority_strs);
-done:
-  gpr_free(uri_str);
   return proxy_name;
 }
 
@@ -119,111 +119,89 @@ std::string MaybeAddDefaultPort(absl::string_view target) {
   return std::string(target);
 }
 
-class HttpProxyMapper : public ProxyMapperInterface {
- public:
-  bool MapName(const char* server_uri, const grpc_channel_args* args,
-               char** name_to_resolve, grpc_channel_args** new_args) override {
-    if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_HTTP_PROXY, true)) {
-      return false;
-    }
-    char* user_cred = nullptr;
-    *name_to_resolve = GetHttpProxyServer(args, &user_cred);
-    if (*name_to_resolve == nullptr) return false;
-    char* no_proxy_str = nullptr;
-    std::string server_target;
-    absl::StatusOr<URI> uri = URI::Parse(server_uri);
-    if (!uri.ok() || uri->path().empty()) {
-      gpr_log(GPR_ERROR,
-              "'http_proxy' environment variable set, but cannot "
-              "parse server URI '%s' -- not using proxy. Error: %s",
-              server_uri, uri.status().ToString().c_str());
-      goto no_use_proxy;
-    }
-    if (uri->scheme() == "unix") {
-      gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
-              server_uri);
-      goto no_use_proxy;
-    }
-    /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
-    no_proxy_str = gpr_getenv("no_grpc_proxy");
-    if (no_proxy_str == nullptr) no_proxy_str = gpr_getenv("no_proxy");
-    if (no_proxy_str != nullptr) {
-      static const char* NO_PROXY_SEPARATOR = ",";
-      bool use_proxy = true;
-      std::string server_host;
-      std::string server_port;
-      if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
-                         &server_port)) {
-        gpr_log(GPR_INFO,
-                "unable to split host and port, not checking no_proxy list for "
-                "host '%s'",
-                server_uri);
-        gpr_free(no_proxy_str);
-      } else {
-        size_t uri_len = server_host.size();
-        char** no_proxy_hosts;
-        size_t num_no_proxy_hosts;
-        gpr_string_split(no_proxy_str, NO_PROXY_SEPARATOR, &no_proxy_hosts,
-                         &num_no_proxy_hosts);
-        for (size_t i = 0; i < num_no_proxy_hosts; i++) {
-          char* no_proxy_entry = no_proxy_hosts[i];
-          size_t no_proxy_len = strlen(no_proxy_entry);
-          if (no_proxy_len <= uri_len &&
-              gpr_stricmp(no_proxy_entry,
-                          &(server_host.c_str()[uri_len - no_proxy_len])) ==
-                  0) {
-            gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
-                    server_uri);
-            use_proxy = false;
-            break;
-          }
-        }
-        for (size_t i = 0; i < num_no_proxy_hosts; i++) {
-          gpr_free(no_proxy_hosts[i]);
-        }
-        gpr_free(no_proxy_hosts);
-        gpr_free(no_proxy_str);
-        if (!use_proxy) goto no_use_proxy;
-      }
-    }
-    server_target =
-        MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")).c_str();
-    grpc_arg args_to_add[2];
-    args_to_add[0] = grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_HTTP_CONNECT_SERVER),
-        const_cast<char*>(server_target.c_str()));
-    if (user_cred != nullptr) {
-      /* Use base64 encoding for user credentials as stated in RFC 7617 */
-      char* encoded_user_cred =
-          grpc_base64_encode(user_cred, strlen(user_cred), 0, 0);
-      std::string header =
-          absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred);
-      gpr_free(encoded_user_cred);
-      args_to_add[1] = grpc_channel_arg_string_create(
-          const_cast<char*>(GRPC_ARG_HTTP_CONNECT_HEADERS),
-          const_cast<char*>(header.c_str()));
-      *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 2);
-    } else {
-      *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 1);
-    }
-    gpr_free(user_cred);
-    return true;
-  no_use_proxy:
+}  // namespace
+
+bool HttpProxyMapper::MapName(const char* server_uri,
+                              const grpc_channel_args* args,
+                              char** name_to_resolve,
+                              grpc_channel_args** new_args) {
+  if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_HTTP_PROXY, true)) {
+    return false;
+  }
+  char* user_cred = nullptr;
+  *name_to_resolve = GetHttpProxyServer(args, &user_cred);
+  if (*name_to_resolve == nullptr) return false;
+  std::string server_target;
+  absl::StatusOr<URI> uri = URI::Parse(server_uri);
+  auto no_use_proxy = [&]() {
     gpr_free(*name_to_resolve);
     *name_to_resolve = nullptr;
     gpr_free(user_cred);
     return false;
+  };
+  if (!uri.ok() || uri->path().empty()) {
+    gpr_log(GPR_ERROR,
+            "'http_proxy' environment variable set, but cannot "
+            "parse server URI '%s' -- not using proxy. Error: %s",
+            server_uri, uri.status().ToString().c_str());
+    return no_use_proxy();
   }
-
-  bool MapAddress(const grpc_resolved_address& /*address*/,
-                  const grpc_channel_args* /*args*/,
-                  grpc_resolved_address** /*new_address*/,
-                  grpc_channel_args** /*new_args*/) override {
-    return false;
+  if (uri->scheme() == "unix") {
+    gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
+            server_uri);
+    return no_use_proxy();
   }
-};
-
-}  // namespace
+  /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
+  auto no_proxy_str = UniquePtr<char>(gpr_getenv("no_grpc_proxy"));
+  if (no_proxy_str == nullptr) {
+    no_proxy_str = UniquePtr<char>(gpr_getenv("no_proxy"));
+  }
+  if (no_proxy_str != nullptr) {
+    bool use_proxy = true;
+    std::string server_host;
+    std::string server_port;
+    if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
+                       &server_port)) {
+      gpr_log(GPR_INFO,
+              "unable to split host and port, not checking no_proxy list for "
+              "host '%s'",
+              server_uri);
+    } else {
+      std::vector<absl::string_view> no_proxy_hosts =
+          absl::StrSplit(no_proxy_str.get(), ',', absl::SkipEmpty());
+      for (const auto& no_proxy_entry : no_proxy_hosts) {
+        if (absl::EndsWithIgnoreCase(server_host, no_proxy_entry)) {
+          gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
+                  server_uri);
+          use_proxy = false;
+          break;
+        }
+      }
+      if (!use_proxy) return no_use_proxy();
+    }
+  }
+  server_target =
+      MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")).c_str();
+  absl::InlinedVector<grpc_arg, 2> args_to_add;
+  args_to_add.push_back(grpc_channel_arg_string_create(
+      const_cast<char*>(GRPC_ARG_HTTP_CONNECT_SERVER),
+      const_cast<char*>(server_target.c_str())));
+  std::string header;
+  if (user_cred != nullptr) {
+    /* Use base64 encoding for user credentials as stated in RFC 7617 */
+    auto encoded_user_cred =
+        UniquePtr<char>(grpc_base64_encode(user_cred, strlen(user_cred), 0, 0));
+    header =
+        absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred.get());
+    args_to_add.push_back(grpc_channel_arg_string_create(
+        const_cast<char*>(GRPC_ARG_HTTP_CONNECT_HEADERS),
+        const_cast<char*>(header.c_str())));
+  }
+  *new_args = grpc_channel_args_copy_and_add(args, args_to_add.data(),
+                                             args_to_add.size());
+  gpr_free(user_cred);
+  return true;
+}
 
 void RegisterHttpProxyMapper() {
   ProxyMapperRegistry::Register(

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

@@ -19,8 +19,25 @@
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
 
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/proxy_mapper.h"
+
 namespace grpc_core {
 
+class HttpProxyMapper : public ProxyMapperInterface {
+ public:
+  bool MapName(const char* server_uri, const grpc_channel_args* args,
+               char** name_to_resolve, grpc_channel_args** new_args) override;
+
+  bool MapAddress(const grpc_resolved_address& /*address*/,
+                  const grpc_channel_args* /*args*/,
+                  grpc_resolved_address** /*new_address*/,
+                  grpc_channel_args** /*new_args*/) override {
+    return false;
+  }
+};
+
 void RegisterHttpProxyMapper();
 
 }  // namespace grpc_core

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

@@ -69,10 +69,11 @@ MakeHierarchicalPathAttribute(std::vector<std::string> path) {
   return absl::make_unique<HierarchicalPathAttribute>(std::move(path));
 }
 
-HierarchicalAddressMap MakeHierarchicalAddressMap(
-    const ServerAddressList& addresses) {
+absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
+    const absl::StatusOr<ServerAddressList>& addresses) {
+  if (!addresses.ok()) return addresses.status();
   HierarchicalAddressMap result;
-  for (const ServerAddress& address : addresses) {
+  for (const ServerAddress& address : *addresses) {
     const HierarchicalPathAttribute* path_attribute =
         static_cast<const HierarchicalPathAttribute*>(
             address.GetAttribute(kHierarchicalPathAttributeKey));

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

@@ -23,7 +23,9 @@
 #include <string>
 #include <vector>
 
-#include "src/core/ext/filters/client_channel/server_address.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/resolver/server_address.h"
 
 // The resolver returns a flat list of addresses.  When a hierarchy of
 // LB policies is in use, each leaf of the hierarchy will need a
@@ -92,10 +94,9 @@ MakeHierarchicalPathAttribute(std::vector<std::string> path);
 using HierarchicalAddressMap = std::map<std::string, ServerAddressList>;
 
 // Splits up the addresses into a separate list for each child.
-HierarchicalAddressMap MakeHierarchicalAddressMap(
-    const ServerAddressList& addresses);
+absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
+    const absl::StatusOr<ServerAddressList>& addresses);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_ADDRESS_FILTERING_H \
-        */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_ADDRESS_FILTERING_H