grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -20,49 +20,74 @@
 
 #include "src/core/ext/transport/chttp2/client/chttp2_connector.h"
 
-#include <string.h>
+#include <stdint.h>
+
+#include <string>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_posix.h>
-#include <grpc/slice_buffer.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/ext/filters/client_channel/client_channel_factory.h"
 #include "src/core/ext/filters/client_channel/connector.h"
+#include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/handshaker.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/iomgr/endpoint.h"
-#include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/resolver/resolver_registry.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/insecure/insecure_credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
 #include "src/core/lib/transport/transport.h"
-#include "src/core/lib/uri/uri_parser.h"
+#include "src/core/lib/transport/transport_fwd.h"
 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
 
 #include <fcntl.h>
 
+#include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/tcp_client_posix.h"
-#include "src/core/lib/iomgr/tcp_posix.h"
 
 #endif  // GPR_SUPPORT_CHANNELS_FROM_FD
 
 namespace grpc_core {
 
-Chttp2Connector::Chttp2Connector() {
-  GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
+namespace {
+void NullThenSchedClosure(const DebugLocation& location, grpc_closure** closure,
+                          grpc_error_handle error) {
+  grpc_closure* c = *closure;
+  *closure = nullptr;
+  ExecCtx::Run(location, c, error);
 }
+}  // namespace
 
 Chttp2Connector::~Chttp2Connector() {
   if (endpoint_ != nullptr) {
@@ -72,99 +97,59 @@ Chttp2Connector::~Chttp2Connector() {
 
 void Chttp2Connector::Connect(const Args& args, Result* result,
                               grpc_closure* notify) {
-  grpc_endpoint** ep;
   {
     MutexLock lock(&mu_);
     GPR_ASSERT(notify_ == nullptr);
     args_ = args;
     result_ = result;
     notify_ = notify;
-    GPR_ASSERT(!connecting_);
-    connecting_ = true;
     GPR_ASSERT(endpoint_ == nullptr);
-    ep = &endpoint_;
   }
-  // In some implementations, the closure can be flushed before
-  // grpc_tcp_client_connect() returns, and since the closure requires access
-  // to mu_, this can result in a deadlock (see
-  // https://github.com/grpc/grpc/issues/16427 for details).
-  // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
-  // make sure that we still exist at that point by taking a ref.
-  Ref().release();  // Ref held by callback.
-  grpc_tcp_client_connect(&connected_, ep, args.interested_parties,
-                          args.channel_args, args.address, args.deadline);
+  absl::StatusOr<std::string> address = grpc_sockaddr_to_uri(args.address);
+  if (!address.ok()) {
+    grpc_error_handle error =
+        GRPC_ERROR_CREATE_FROM_CPP_STRING(address.status().ToString());
+    NullThenSchedClosure(DEBUG_LOCATION, &notify_, error);
+    return;
+  }
+  absl::InlinedVector<grpc_arg, 2> args_to_add = {
+      grpc_channel_arg_string_create(
+          const_cast<char*>(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS),
+          const_cast<char*>(address.value().c_str())),
+      grpc_channel_arg_integer_create(
+          const_cast<char*>(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET),
+          1),
+  };
+  grpc_channel_args* channel_args = grpc_channel_args_copy_and_add(
+      args_.channel_args, args_to_add.data(), args_to_add.size());
+  handshake_mgr_ = MakeRefCounted<HandshakeManager>();
+  CoreConfiguration::Get().handshaker_registry().AddHandshakers(
+      HANDSHAKER_CLIENT, channel_args, args_.interested_parties,
+      handshake_mgr_.get());
+  Ref().release();  // Ref held by OnHandshakeDone().
+  handshake_mgr_->DoHandshake(nullptr /* endpoint */, channel_args,
+                              args.deadline, nullptr /* acceptor */,
+                              OnHandshakeDone, this);
+  grpc_channel_args_destroy(channel_args);
 }
 
 void Chttp2Connector::Shutdown(grpc_error_handle error) {
   MutexLock lock(&mu_);
   shutdown_ = true;
   if (handshake_mgr_ != nullptr) {
+    // Handshaker will also shutdown the endpoint if it exists
     handshake_mgr_->Shutdown(GRPC_ERROR_REF(error));
   }
-  // If handshaking is not yet in progress, shutdown the endpoint.
-  // Otherwise, the handshaker will do this for us.
-  if (!connecting_ && endpoint_ != nullptr) {
-    grpc_endpoint_shutdown(endpoint_, GRPC_ERROR_REF(error));
-  }
   GRPC_ERROR_UNREF(error);
 }
 
-void Chttp2Connector::Connected(void* arg, grpc_error_handle error) {
-  Chttp2Connector* self = static_cast<Chttp2Connector*>(arg);
-  bool unref = false;
-  {
-    MutexLock lock(&self->mu_);
-    GPR_ASSERT(self->connecting_);
-    self->connecting_ = false;
-    if (error != GRPC_ERROR_NONE || self->shutdown_) {
-      if (error == GRPC_ERROR_NONE) {
-        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
-      } else {
-        error = GRPC_ERROR_REF(error);
-      }
-      if (self->endpoint_ != nullptr) {
-        grpc_endpoint_shutdown(self->endpoint_, GRPC_ERROR_REF(error));
-      }
-      self->result_->Reset();
-      grpc_closure* notify = self->notify_;
-      self->notify_ = nullptr;
-      ExecCtx::Run(DEBUG_LOCATION, notify, error);
-      unref = true;
-    } else {
-      GPR_ASSERT(self->endpoint_ != nullptr);
-      self->StartHandshakeLocked();
-    }
-  }
-  if (unref) self->Unref();
-}
-
-void Chttp2Connector::StartHandshakeLocked() {
-  handshake_mgr_ = MakeRefCounted<HandshakeManager>();
-  CoreConfiguration::Get().handshaker_registry().AddHandshakers(
-      HANDSHAKER_CLIENT, args_.channel_args, args_.interested_parties,
-      handshake_mgr_.get());
-  grpc_endpoint_add_to_pollset_set(endpoint_, args_.interested_parties);
-  handshake_mgr_->DoHandshake(endpoint_, args_.channel_args, args_.deadline,
-                              nullptr /* acceptor */, OnHandshakeDone, this);
-  endpoint_ = nullptr;  // Endpoint handed off to handshake manager.
-}
-
-namespace {
-void NullThenSchedClosure(const DebugLocation& location, grpc_closure** closure,
-                          grpc_error_handle error) {
-  grpc_closure* c = *closure;
-  *closure = nullptr;
-  ExecCtx::Run(location, c, error);
-}
-}  // namespace
-
 void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
   auto* args = static_cast<HandshakerArgs*>(arg);
   Chttp2Connector* self = static_cast<Chttp2Connector*>(args->user_data);
   {
     MutexLock lock(&self->mu_);
-    if (error != GRPC_ERROR_NONE || self->shutdown_) {
-      if (error == GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error) || self->shutdown_) {
+      if (GRPC_ERROR_IS_NONE(error)) {
         error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
         // We were shut down after handshaking completed successfully, so
         // destroy the endpoint here.
@@ -221,7 +206,7 @@ void Chttp2Connector::OnReceiveSettings(void* arg, grpc_error_handle error) {
     if (!self->notify_error_.has_value()) {
       grpc_endpoint_delete_from_pollset_set(self->endpoint_,
                                             self->args_.interested_parties);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         // Transport got an error while waiting on SETTINGS frame.
         // TODO(yashykt): The following two lines should be moved to
         // SubchannelConnector::Result::Reset()
@@ -306,7 +291,8 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
     if (channel_credentials == nullptr) {
       gpr_log(GPR_ERROR,
               "Can't create subchannel: channel credentials missing for secure "
-              "channel.");
+              "channel. Got args: %s",
+              grpc_channel_args_string(args).c_str());
       return nullptr;
     }
     // Make sure security connector does not already exist in args.
@@ -344,29 +330,19 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
   }
 };
 
-grpc_channel* CreateChannel(const char* target, const grpc_channel_args* args,
-                            grpc_error_handle* error) {
+absl::StatusOr<RefCountedPtr<Channel>> CreateChannel(const char* target,
+                                                     ChannelArgs args) {
   if (target == nullptr) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
-    if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("channel target is NULL");
-    }
-    return nullptr;
+    return absl::InvalidArgumentError("channel target is NULL");
   }
   // Add channel arg containing the server URI.
   std::string canonical_target =
       CoreConfiguration::Get().resolver_registry().AddDefaultPrefixIfNeeded(
           target);
-  grpc_arg arg = grpc_channel_arg_string_create(
-      const_cast<char*>(GRPC_ARG_SERVER_URI),
-      const_cast<char*>(canonical_target.c_str()));
-  const char* to_remove[] = {GRPC_ARG_SERVER_URI};
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
-  grpc_channel* channel = grpc_channel_create_internal(
-      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, error);
-  grpc_channel_args_destroy(new_args);
-  return channel;
+  return Channel::Create(target,
+                         args.Set(GRPC_ARG_SERVER_URI, canonical_target),
+                         GRPC_CLIENT_CHANNEL, nullptr);
 }
 
 }  // namespace
@@ -389,33 +365,30 @@ void FactoryInit() {
 //                   - perform handshakes
 grpc_channel* grpc_channel_create(const char* target,
                                   grpc_channel_credentials* creds,
-                                  const grpc_channel_args* args) {
+                                  const grpc_channel_args* c_args) {
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_secure_channel_create(target=%s, creds=%p, args=%p)", 3,
-                 (target, (void*)creds, (void*)args));
-  args = grpc_core::CoreConfiguration::Get()
-             .channel_args_preconditioning()
-             .PreconditionChannelArgs(args);
+                 (target, (void*)creds, (void*)c_args));
   grpc_channel* channel = nullptr;
   grpc_error_handle error = GRPC_ERROR_NONE;
   if (creds != nullptr) {
     // Add channel args containing the client channel factory and channel
     // credentials.
     gpr_once_init(&g_factory_once, FactoryInit);
-    grpc_arg channel_factory_arg =
-        grpc_core::ClientChannelFactory::CreateChannelArg(g_factory);
-    grpc_arg args_to_add[] = {channel_factory_arg,
-                              grpc_channel_credentials_to_arg(creds)};
-    const char* arg_to_remove = channel_factory_arg.key;
-    grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
-        args, &arg_to_remove, 1, args_to_add, GPR_ARRAY_SIZE(args_to_add));
-    new_args = creds->update_arguments(new_args);
+    grpc_core::ChannelArgs args =
+        creds->update_arguments(grpc_core::CoreConfiguration::Get()
+                                    .channel_args_preconditioning()
+                                    .PreconditionChannelArgs(c_args)
+                                    .SetObject(creds->Ref())
+                                    .SetObject(g_factory));
     // Create channel.
-    channel = grpc_core::CreateChannel(target, new_args, &error);
-    // Clean up.
-    grpc_channel_args_destroy(new_args);
+    auto r = grpc_core::CreateChannel(target, args);
+    if (r.ok()) {
+      channel = r->release()->c_ptr();
+    } else {
+      error = absl_status_to_grpc_error(r.status());
+    }
   }
-  grpc_channel_args_destroy(args);
   if (channel == nullptr) {
     intptr_t integer;
     grpc_status_code status = GRPC_STATUS_INTERNAL;
@@ -439,19 +412,18 @@ grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
       (target, fd, creds, args));
   // For now, we only support insecure channel credentials.
   if (creds == nullptr ||
-      creds->type() != grpc_core::InsecureServerCredentials::Type()) {
+      creds->type() != grpc_core::InsecureCredentials::Type()) {
     return grpc_lame_client_channel_create(
         target, GRPC_STATUS_INTERNAL,
         "Failed to create client channel due to invalid creds");
   }
-  grpc_arg default_authority_arg = grpc_channel_arg_string_create(
-      const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
-      const_cast<char*>("test.authority"));
-  args = grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
-  const grpc_channel_args* final_args = grpc_core::CoreConfiguration::Get()
-                                            .channel_args_preconditioning()
-                                            .PreconditionChannelArgs(args);
-  grpc_channel_args_destroy(args);
+  const grpc_channel_args* final_args =
+      grpc_core::CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(args)
+          .SetIfUnset(GRPC_ARG_DEFAULT_AUTHORITY, "test.authority")
+          .SetObject(creds->Ref())
+          .ToC();
 
   int flags = fcntl(fd, F_GETFL, 0);
   GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
@@ -460,26 +432,20 @@ grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
   grpc_transport* transport =
       grpc_create_chttp2_transport(final_args, client, true);
   GPR_ASSERT(transport);
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_channel* channel = grpc_channel_create_internal(
-      target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport, &error);
+  auto channel = grpc_core::Channel::Create(
+      target, grpc_core::ChannelArgs::FromC(final_args),
+      GRPC_CLIENT_DIRECT_CHANNEL, transport);
   grpc_channel_args_destroy(final_args);
-  if (channel != nullptr) {
+  if (channel.ok()) {
     grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr);
     grpc_core::ExecCtx::Get()->Flush();
+    return channel->release()->c_ptr();
   } else {
-    intptr_t integer;
-    grpc_status_code status = GRPC_STATUS_INTERNAL;
-    if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {
-      status = static_cast<grpc_status_code>(integer);
-    }
-    GRPC_ERROR_UNREF(error);
     grpc_transport_destroy(transport);
-    channel = grpc_lame_client_channel_create(
-        target, status, "Failed to create client channel");
+    return grpc_lame_client_channel_create(
+        target, static_cast<grpc_status_code>(channel.status().code()),
+        "Failed to create client channel");
   }
-
-  return channel;
 }
 
 #else  // !GPR_SUPPORT_CHANNELS_FROM_FD

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -21,23 +21,27 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/types/optional.h"
+
 #include "src/core/ext/filters/client_channel/connector.h"
-#include "src/core/lib/channel/handshaker.h"
-#include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/transport/handshaker.h"
 
 namespace grpc_core {
 
 class Chttp2Connector : public SubchannelConnector {
  public:
-  Chttp2Connector();
   ~Chttp2Connector() override;
 
   void Connect(const Args& args, Result* result, grpc_closure* notify) override;
   void Shutdown(grpc_error_handle error) override;
 
  private:
-  static void Connected(void* arg, grpc_error_handle error);
-  void StartHandshakeLocked();
   static void OnHandshakeDone(void* arg, grpc_error_handle error);
   static void OnReceiveSettings(void* arg, grpc_error_handle error);
   static void OnTimeout(void* arg, grpc_error_handle error);
@@ -58,11 +62,9 @@ class Chttp2Connector : public SubchannelConnector {
   Result* result_ = nullptr;
   grpc_closure* notify_ = nullptr;
   bool shutdown_ = false;
-  bool connecting_ = false;
   // Holds the endpoint when first created before being handed off to
   // the handshake manager, and then again after handshake is done.
   grpc_endpoint* endpoint_ = nullptr;
-  grpc_closure connected_;
   grpc_closure on_receive_settings_;
   grpc_timer timer_;
   grpc_closure on_timeout_;

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -24,11 +24,20 @@
 #include <limits.h>
 #include <string.h>
 
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
 #include <vector>
 
-#include "absl/strings/match.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
 #include <grpc/grpc.h>
@@ -36,38 +45,53 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
 
-#include "src/core/ext/filters/http/server/http_server_filter.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/handshaker.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.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/gprpp/time.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
-#include "src/core/lib/security/context/security_context.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/insecure/insecure_credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
-
+#include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
-#include "src/core/lib/surface/completion_queue.h"
-
 #endif  // GPR_SUPPORT_CHANNELS_FROM_FD
 
 namespace grpc_core {
@@ -301,7 +325,7 @@ void Chttp2ServerListener::ConfigFetcherWatcher::UpdateConnectionManager(
   int port_temp;
   grpc_error_handle error = grpc_tcp_server_add_port(
       listener_->tcp_server_, &listener_->resolved_address_, &port_temp);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     GRPC_ERROR_UNREF(error);
     gpr_log(GPR_ERROR, "Error adding port to server: %s",
             grpc_error_std_string(error).c_str());
@@ -422,11 +446,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
   bool cleanup_connection = false;
   {
     MutexLock connection_lock(&self->connection_->mu_);
-    if (error != GRPC_ERROR_NONE || self->connection_->shutdown_) {
+    if (!GRPC_ERROR_IS_NONE(error) || self->connection_->shutdown_) {
       std::string error_str = grpc_error_std_string(error);
       gpr_log(GPR_DEBUG, "Handshaking failed: %s", error_str.c_str());
       cleanup_connection = true;
-      if (error == GRPC_ERROR_NONE && args->endpoint != nullptr) {
+      if (GRPC_ERROR_IS_NONE(error) && args->endpoint != nullptr) {
         // We were shut down or stopped serving after handshaking completed
         // successfully, so destroy the endpoint here.
         // TODO(ctiller): It is currently necessary to shutdown endpoints
@@ -450,7 +474,7 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
             self->connection_->listener_->server_->SetupTransport(
                 transport, self->accepting_pollset_, args->args,
                 grpc_chttp2_transport_get_socket_node(transport));
-        if (channel_init_err == GRPC_ERROR_NONE) {
+        if (GRPC_ERROR_IS_NONE(channel_init_err)) {
           // Use notify_on_receive_settings callback to enforce the
           // handshake deadline.
           // Note: The reinterpret_cast<>s here are safe, because
@@ -629,7 +653,7 @@ void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry(
   ActiveConnection* self = static_cast<ActiveConnection*>(arg);
   // If the drain_grace_timer_ was not cancelled, disconnect the transport
   // immediately.
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     grpc_chttp2_transport* transport = nullptr;
     {
       MutexLock lock(&self->mu_);
@@ -659,29 +683,33 @@ grpc_error_handle Chttp2ServerListener::Create(
     listener = new Chttp2ServerListener(server, args, args_modifier);
     error = grpc_tcp_server_create(&listener->tcp_server_shutdown_complete_,
                                    args, &listener->tcp_server_);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     if (server->config_fetcher() != nullptr) {
       listener->resolved_address_ = *addr;
       // TODO(yashykt): Consider binding so as to be able to return the port
       // number.
     } else {
       error = grpc_tcp_server_add_port(listener->tcp_server_, addr, port_num);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
     // Create channelz node.
     if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ,
                                     GRPC_ENABLE_CHANNELZ_DEFAULT)) {
-      std::string string_address = grpc_sockaddr_to_uri(addr);
+      auto string_address = grpc_sockaddr_to_uri(addr);
+      if (!string_address.ok()) {
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+            string_address.status().ToString());
+      }
       listener->channelz_listen_socket_ =
           MakeRefCounted<channelz::ListenSocketNode>(
-              string_address.c_str(),
-              absl::StrFormat("chttp2 listener %s", string_address.c_str()));
+              *string_address,
+              absl::StrCat("chttp2 listener ", *string_address));
     }
     // Register with the server only upon success
     server->AddListener(OrphanablePtr<Server::ListenerInterface>(listener));
     return GRPC_ERROR_NONE;
   }();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (listener != nullptr) {
       if (listener->tcp_server_ != nullptr) {
         // listener is deleted when tcp_server_ is shutdown.
@@ -703,7 +731,7 @@ grpc_error_handle Chttp2ServerListener::CreateWithAcceptor(
       new Chttp2ServerListener(server, args, args_modifier);
   grpc_error_handle error = grpc_tcp_server_create(
       &listener->tcp_server_shutdown_complete_, args, &listener->tcp_server_);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     delete listener;
     return error;
   }
@@ -744,7 +772,8 @@ void Chttp2ServerListener::Start(
     auto watcher = absl::make_unique<ConfigFetcherWatcher>(Ref());
     config_fetcher_watcher_ = watcher.get();
     server_->config_fetcher()->StartWatch(
-        grpc_sockaddr_to_string(&resolved_address_, false), std::move(watcher));
+        grpc_sockaddr_to_string(&resolved_address_, false).value(),
+        std::move(watcher));
   } else {
     {
       MutexLock lock(&mu_);
@@ -803,7 +832,7 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     }
     grpc_error_handle error = GRPC_ERROR_NONE;
     args = self->args_modifier_(*args_result, &error);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_DEBUG, "Closing connection: %s",
               grpc_error_std_string(error).c_str());
       endpoint_cleanup(error);
@@ -930,7 +959,7 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
       error = Chttp2ServerListener::Create(server, &addr,
                                            grpc_channel_args_copy(args),
                                            args_modifier, &port_temp);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         error_list.push_back(error);
       } else {
         if (*port_num == -1) {
@@ -963,7 +992,7 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
     GRPC_ERROR_UNREF(error);
   }
   grpc_channel_args_destroy(args);
-  if (error != GRPC_ERROR_NONE) *port_num = 0;
+  if (!GRPC_ERROR_IS_NONE(error)) *port_num = 0;
   return error;
 }
 
@@ -984,7 +1013,7 @@ grpc_channel_args* ModifyArgsForConnection(grpc_channel_args* args,
   if (security_connector == nullptr) {
     *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrCat("Unable to create secure server with credentials of type ",
-                     server_credentials->type()));
+                     server_credentials->type().name()));
     return args;
   }
   grpc_arg arg_to_add =
@@ -1033,7 +1062,7 @@ int grpc_server_add_http2_port(grpc_server* server, const char* addr,
     if (sc == nullptr) {
       err = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
           "Unable to create secure server with credentials of type ",
-          creds->type()));
+          creds->type().name()));
       goto done;
     }
     grpc_arg args_to_add[2];
@@ -1047,7 +1076,7 @@ int grpc_server_add_http2_port(grpc_server* server, const char* addr,
                                        ModifyArgsForConnection, &port_num);
 done:
   sc.reset(DEBUG_LOCATION, "server");
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(err).c_str());
 
     GRPC_ERROR_UNREF(err);
@@ -1078,7 +1107,7 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
   );
   grpc_error_handle error =
       core_server->SetupTransport(transport, nullptr, server_args, nullptr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     for (grpc_pollset* pollset : core_server->pollsets()) {
       grpc_endpoint_add_to_pollset(server_endpoint, pollset);
     }