grpc 1.63.0 → 1.66.0

data/src/core/{lib/transport → handshaker/tcp_connect}/tcp_connect_handshaker.cc

@@ -16,13 +16,14 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/transport/tcp_connect_handshaker.h"
+#include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
 
 #include <memory>
+#include <utility>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
@@ -31,7 +32,11 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/handshaker/handshaker.h"
+#include "src/core/handshaker/handshaker_factory.h"
+#include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -49,9 +54,6 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/transport/handshaker.h"
-#include "src/core/lib/transport/handshaker_factory.h"
-#include "src/core/lib/transport/handshaker_registry.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -61,24 +63,23 @@ namespace {
 class TCPConnectHandshaker : public Handshaker {
  public:
   explicit TCPConnectHandshaker(grpc_pollset_set* pollset_set);
-  void Shutdown(grpc_error_handle why) override;
-  void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
-                   grpc_closure* on_handshake_done,
-                   HandshakerArgs* args) override;
-  const char* name() const override { return "tcp_connect"; }
+  absl::string_view name() const override { return "tcp_connect"; }
+  void DoHandshake(
+      HandshakerArgs* args,
+      absl::AnyInvocable<void(absl::Status)> on_handshake_done) override;
+  void Shutdown(absl::Status error) override;
 
  private:
   ~TCPConnectHandshaker() override;
-  void CleanupArgsForFailureLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  void FinishLocked(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void FinishLocked(absl::Status error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   static void Connected(void* arg, grpc_error_handle error);
 
   Mutex mu_;
   bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
-  // Endpoint and read buffer to destroy after a shutdown.
+  // Endpoint to destroy after a shutdown.
   grpc_endpoint* endpoint_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
-  grpc_slice_buffer* read_buffer_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
-  grpc_closure* on_handshake_done_ ABSL_GUARDED_BY(mu_) = nullptr;
+  absl::AnyInvocable<void(absl::Status)> on_handshake_done_
+      ABSL_GUARDED_BY(mu_);
   grpc_pollset_set* interested_parties_ = nullptr;
   grpc_polling_entity pollent_;
   HandshakerArgs* args_ = nullptr;
@@ -99,33 +100,32 @@ TCPConnectHandshaker::TCPConnectHandshaker(grpc_pollset_set* pollset_set)
   GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
 }
 
-void TCPConnectHandshaker::Shutdown(grpc_error_handle /*why*/) {
+void TCPConnectHandshaker::Shutdown(absl::Status /*error*/) {
   // TODO(anramach): After migration to EventEngine, cancel the in-progress
   // TCP connection attempt.
-  {
-    MutexLock lock(&mu_);
-    if (!shutdown_) {
-      shutdown_ = true;
-      // If we are shutting down while connecting, respond back with
-      // handshake done.
-      // The callback from grpc_tcp_client_connect will perform
-      // the necessary clean up.
-      if (on_handshake_done_ != nullptr) {
-        CleanupArgsForFailureLocked();
-        FinishLocked(GRPC_ERROR_CREATE("tcp handshaker shutdown"));
-      }
+  MutexLock lock(&mu_);
+  if (!shutdown_) {
+    shutdown_ = true;
+    // If we are shutting down while connecting, respond back with
+    // handshake done.
+    // The callback from grpc_tcp_client_connect will perform
+    // the necessary clean up.
+    if (on_handshake_done_ != nullptr) {
+      // TODO(roth): When we remove the legacy grpc_error APIs, propagate the
+      // status passed to shutdown as part of the message here.
+      FinishLocked(GRPC_ERROR_CREATE("tcp handshaker shutdown"));
     }
   }
 }
 
-void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
-                                       grpc_closure* on_handshake_done,
-                                       HandshakerArgs* args) {
+void TCPConnectHandshaker::DoHandshake(
+    HandshakerArgs* args,
+    absl::AnyInvocable<void(absl::Status)> on_handshake_done) {
   {
     MutexLock lock(&mu_);
-    on_handshake_done_ = on_handshake_done;
+    on_handshake_done_ = std::move(on_handshake_done);
   }
-  GPR_ASSERT(args->endpoint == nullptr);
+  CHECK_EQ(args->endpoint.get(), nullptr);
   args_ = args;
   absl::StatusOr<URI> uri = URI::Parse(
       args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
@@ -149,7 +149,7 @@ void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   Ref().release();  // Ref held by callback.
   // As we fake the TCP client connection failure when shutdown is called
   // we don't want to pass args->endpoint directly.
-  // Instead pass endpoint_ and swap this endpoint to
+  // Instead pass endpoint_to_destroy_ and swap this endpoint to
   // args endpoint on success.
   grpc_tcp_client_connect(
       &connected_, &endpoint_to_destroy_, interested_parties_,
@@ -167,24 +167,23 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
         error = GRPC_ERROR_CREATE("tcp handshaker shutdown");
       }
       if (self->endpoint_to_destroy_ != nullptr) {
-        grpc_endpoint_shutdown(self->endpoint_to_destroy_, error);
+        grpc_endpoint_destroy(self->endpoint_to_destroy_);
+        self->endpoint_to_destroy_ = nullptr;
       }
       if (!self->shutdown_) {
-        self->CleanupArgsForFailureLocked();
         self->shutdown_ = true;
-        self->FinishLocked(error);
+        self->FinishLocked(std::move(error));
       } else {
-        // The on_handshake_done_ is already as part of shutdown when
-        // connecting So nothing to be done here other than unrefing the
-        // error.
+        // The on_handshake_done_ callback was already invoked as part of
+        // shutdown when connecting, so nothing to be done here.
       }
       return;
     }
-    GPR_ASSERT(self->endpoint_to_destroy_ != nullptr);
-    self->args_->endpoint = self->endpoint_to_destroy_;
+    CHECK_NE(self->endpoint_to_destroy_, nullptr);
+    self->args_->endpoint.reset(self->endpoint_to_destroy_);
     self->endpoint_to_destroy_ = nullptr;
     if (self->bind_endpoint_to_pollset_) {
-      grpc_endpoint_add_to_pollset_set(self->args_->endpoint,
+      grpc_endpoint_add_to_pollset_set(self->args_->endpoint.get(),
                                        self->interested_parties_);
     }
     self->FinishLocked(absl::OkStatus());
@@ -195,25 +194,14 @@ TCPConnectHandshaker::~TCPConnectHandshaker() {
   if (endpoint_to_destroy_ != nullptr) {
     grpc_endpoint_destroy(endpoint_to_destroy_);
   }
-  if (read_buffer_to_destroy_ != nullptr) {
-    grpc_slice_buffer_destroy(read_buffer_to_destroy_);
-    gpr_free(read_buffer_to_destroy_);
-  }
   grpc_pollset_set_destroy(interested_parties_);
 }
 
-void TCPConnectHandshaker::CleanupArgsForFailureLocked() {
-  read_buffer_to_destroy_ = args_->read_buffer;
-  args_->read_buffer = nullptr;
-  args_->args = ChannelArgs();
-}
-
-void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
+void TCPConnectHandshaker::FinishLocked(absl::Status error) {
   if (interested_parties_ != nullptr) {
     grpc_polling_entity_del_from_pollset_set(&pollent_, interested_parties_);
   }
-  ExecCtx::Run(DEBUG_LOCATION, on_handshake_done_, error);
-  on_handshake_done_ = nullptr;
+  InvokeOnHandshakeDone(args_, std::move(on_handshake_done_), std::move(error));
 }
 
 //

data/src/core/{lib/transport → handshaker/tcp_connect}/tcp_connect_handshaker.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+#ifndef GRPC_SRC_CORE_HANDSHAKER_TCP_CONNECT_TCP_CONNECT_HANDSHAKER_H
+#define GRPC_SRC_CORE_HANDSHAKER_TCP_CONNECT_TCP_CONNECT_HANDSHAKER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -36,4 +36,4 @@ void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+#endif  // GRPC_SRC_CORE_HANDSHAKER_TCP_CONNECT_TCP_CONNECT_HANDSHAKER_H

data/src/core/lib/address_utils/parse_address.cc

@@ -16,10 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/address_utils/parse_address.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
 
 #ifdef GRPC_HAVE_VSOCK
@@ -41,18 +41,18 @@
 #endif  // GRPC_HAVE_UNIX_SOCKET
 #include <string>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/grpc_if_nametoindex.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
+#include "src/core/util/string.h"
 
 // IWYU pragma: no_include <arpa/inet.h>
 
@@ -61,14 +61,13 @@
 bool grpc_parse_unix(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "unix") {
-    gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'unix' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   grpc_error_handle error =
       grpc_core::UnixSockaddrPopulate(uri.path(), resolved_addr);
   if (!error.ok()) {
-    gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "" << grpc_core::StatusToString(error);
     return false;
   }
   return true;
@@ -77,14 +76,14 @@ bool grpc_parse_unix(const grpc_core::URI& uri,
 bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
                               grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "unix-abstract") {
-    gpr_log(GPR_ERROR, "Expected 'unix-abstract' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'unix-abstract' scheme, got '" << uri.scheme()
+               << "'";
     return false;
   }
   grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(uri.path(), resolved_addr);
   if (!error.ok()) {
-    gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "" << grpc_core::StatusToString(error);
     return false;
   }
   return true;
@@ -161,14 +160,13 @@ grpc_error_handle UnixAbstractSockaddrPopulate(
 bool grpc_parse_vsock(const grpc_core::URI& uri,
                       grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "vsock") {
-    gpr_log(GPR_ERROR, "Expected 'vsock' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'vsock' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   grpc_error_handle error =
       grpc_core::VSockaddrPopulate(uri.path(), resolved_addr);
   if (!error.ok()) {
-    gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "" << grpc_core::StatusToString(error);
     return false;
   }
   return true;
@@ -218,8 +216,7 @@ bool grpc_parse_ipv4_hostport(absl::string_view hostport,
   std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)",
-              std::string(hostport).c_str());
+      LOG(ERROR) << "Failed gpr_split_host_port(" << hostport << ", ...)";
     }
     return false;
   }
@@ -230,19 +227,19 @@ bool grpc_parse_ipv4_hostport(absl::string_view hostport,
   in->sin_family = GRPC_AF_INET;
   if (grpc_inet_pton(GRPC_AF_INET, host.c_str(), &in->sin_addr) == 0) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host.c_str());
+      LOG(ERROR) << "invalid ipv4 address: '" << host << "'";
     }
     goto done;
   }
   // Parse port.
   if (port.empty()) {
-    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
+    if (log_errors) LOG(ERROR) << "no port given for ipv4 scheme";
     goto done;
   }
   int port_num;
   if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
       port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port.c_str());
+    if (log_errors) LOG(ERROR) << "invalid ipv4 port: '" << port << "'";
     goto done;
   }
   in->sin_port = grpc_htons(static_cast<uint16_t>(port_num));
@@ -254,8 +251,7 @@ done:
 bool grpc_parse_ipv4(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "ipv4") {
-    gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'ipv4' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   return grpc_parse_ipv4_hostport(absl::StripPrefix(uri.path(), "/"),
@@ -270,8 +266,7 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
   std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)",
-              std::string(hostport).c_str());
+      LOG(ERROR) << "Failed gpr_split_host_port(" << hostport << ", ...)";
     }
     return false;
   }
@@ -284,18 +279,16 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
   char* host_end =
       static_cast<char*>(gpr_memrchr(host.c_str(), '%', host.size()));
   if (host_end != nullptr) {
-    GPR_ASSERT(host_end >= host.c_str());
+    CHECK(host_end >= host.c_str());
     char host_without_scope[GRPC_INET6_ADDRSTRLEN + 1];
     size_t host_without_scope_len =
         static_cast<size_t>(host_end - host.c_str());
     uint32_t sin6_scope_id = 0;
     if (host_without_scope_len > GRPC_INET6_ADDRSTRLEN) {
       if (log_errors) {
-        gpr_log(
-            GPR_ERROR,
-            "invalid ipv6 address length %zu. Length cannot be greater than "
-            "GRPC_INET6_ADDRSTRLEN i.e %d)",
-            host_without_scope_len, GRPC_INET6_ADDRSTRLEN);
+        LOG(ERROR) << "invalid ipv6 address length " << host_without_scope_len
+                   << ". Length cannot be greater than "
+                   << "GRPC_INET6_ADDRSTRLEN i.e " << GRPC_INET6_ADDRSTRLEN;
       }
       goto done;
     }
@@ -304,7 +297,7 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
     if (grpc_inet_pton(GRPC_AF_INET6, host_without_scope, &in6->sin6_addr) ==
         0) {
       if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host_without_scope);
+        LOG(ERROR) << "invalid ipv6 address: '" << host_without_scope << "'";
       }
       goto done;
     }
@@ -312,10 +305,8 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
                                   host.size() - host_without_scope_len - 1,
                                   &sin6_scope_id) == 0) {
       if ((sin6_scope_id = grpc_if_nametoindex(host_end + 1)) == 0) {
-        gpr_log(GPR_ERROR,
-                "Invalid interface name: '%s'. "
-                "Non-numeric and failed if_nametoindex.",
-                host_end + 1);
+        LOG(ERROR) << "Invalid interface name: '" << host_end + 1
+                   << "'. Non-numeric and failed if_nametoindex.";
         goto done;
       }
     }
@@ -324,20 +315,20 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
   } else {
     if (grpc_inet_pton(GRPC_AF_INET6, host.c_str(), &in6->sin6_addr) == 0) {
       if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host.c_str());
+        LOG(ERROR) << "invalid ipv6 address: '" << host << "'";
       }
       goto done;
     }
   }
   // Parse port.
   if (port.empty()) {
-    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
+    if (log_errors) LOG(ERROR) << "no port given for ipv6 scheme";
     goto done;
   }
   int port_num;
   if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
       port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port.c_str());
+    if (log_errors) LOG(ERROR) << "invalid ipv6 port: '" << port << "'";
     goto done;
   }
   in6->sin6_port = grpc_htons(static_cast<uint16_t>(port_num));
@@ -349,8 +340,7 @@ done:
 bool grpc_parse_ipv6(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "ipv6") {
-    gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'ipv6' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   return grpc_parse_ipv6_hostport(absl::StripPrefix(uri.path(), "/"),
@@ -374,7 +364,7 @@ bool grpc_parse_uri(const grpc_core::URI& uri,
   if (uri.scheme() == "ipv6") {
     return grpc_parse_ipv6(uri, resolved_addr);
   }
-  gpr_log(GPR_ERROR, "Can't parse scheme '%s'", uri.scheme().c_str());
+  LOG(ERROR) << "Can't parse scheme '" << uri.scheme() << "'";
   return false;
 }
 

data/src/core/lib/address_utils/parse_address.h

@@ -19,13 +19,13 @@
 #ifndef GRPC_SRC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H
 #define GRPC_SRC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/uri/uri_parser.h"

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -16,12 +16,14 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 
 #include <errno.h>
 #include <inttypes.h>
+
+#include "absl/log/check.h"
+
+#include <grpc/support/port_platform.h>
 #ifdef GRPC_HAVE_VSOCK
 #include <linux/vm_sockets.h>
 #endif
@@ -30,12 +32,11 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/port.h"
@@ -110,7 +111,7 @@ static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
 
 int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
                               grpc_resolved_address* resolved_addr4_out) {
-  GPR_ASSERT(resolved_addr != resolved_addr4_out);
+  CHECK(resolved_addr != resolved_addr4_out);
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   grpc_sockaddr_in* addr4_out =
@@ -140,7 +141,7 @@ int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
 
 int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* resolved_addr,
                               grpc_resolved_address* resolved_addr6_out) {
-  GPR_ASSERT(resolved_addr != resolved_addr6_out);
+  CHECK(resolved_addr != resolved_addr6_out);
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   grpc_sockaddr_in6* addr6_out =
@@ -203,7 +204,8 @@ void grpc_sockaddr_make_wildcard4(int port,
                                   grpc_resolved_address* resolved_wild_out) {
   grpc_sockaddr_in* wild_out =
       reinterpret_cast<grpc_sockaddr_in*>(resolved_wild_out->addr);
-  GPR_ASSERT(port >= 0 && port < 65536);
+  CHECK(port >= 0);
+  CHECK(port < 65536);
   memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
   wild_out->sin_family = GRPC_AF_INET;
   wild_out->sin_port = grpc_htons(static_cast<uint16_t>(port));
@@ -214,7 +216,8 @@ void grpc_sockaddr_make_wildcard6(int port,
                                   grpc_resolved_address* resolved_wild_out) {
   grpc_sockaddr_in6* wild_out =
       reinterpret_cast<grpc_sockaddr_in6*>(resolved_wild_out->addr);
-  GPR_ASSERT(port >= 0 && port < 65536);
+  CHECK(port >= 0);
+  CHECK(port < 65536);
   memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
   wild_out->sin6_family = GRPC_AF_INET6;
   wild_out->sin6_port = grpc_htons(static_cast<uint16_t>(port));
@@ -368,8 +371,8 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
       return 1;
 #endif
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in grpc_sockaddr_get_port";
       return 0;
   }
 }
@@ -378,18 +381,20 @@ int grpc_sockaddr_set_port(grpc_resolved_address* resolved_addr, int port) {
   grpc_sockaddr* addr = reinterpret_cast<grpc_sockaddr*>(resolved_addr->addr);
   switch (addr->sa_family) {
     case GRPC_AF_INET:
-      GPR_ASSERT(port >= 0 && port < 65536);
+      CHECK(port >= 0);
+      CHECK(port < 65536);
       (reinterpret_cast<grpc_sockaddr_in*>(addr))->sin_port =
           grpc_htons(static_cast<uint16_t>(port));
       return 1;
     case GRPC_AF_INET6:
-      GPR_ASSERT(port >= 0 && port < 65536);
+      CHECK(port >= 0);
+      CHECK(port < 65536);
       (reinterpret_cast<grpc_sockaddr_in6*>(addr))->sin6_port =
           grpc_htons(static_cast<uint16_t>(port));
       return 1;
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in grpc_sockaddr_set_port";
       return 0;
   }
 }
@@ -437,7 +442,7 @@ void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
     // We cannot use s6_addr32 since it is not defined on all platforms that we
     // need it on.
     uint32_t address_parts[4];
-    GPR_ASSERT(sizeof(addr6->sin6_addr) == sizeof(address_parts));
+    CHECK(sizeof(addr6->sin6_addr) == sizeof(address_parts));
     memcpy(address_parts, &addr6->sin6_addr, sizeof(grpc_in6_addr));
     if (mask_bits <= 32) {
       uint32_t mask_ip_addr = (~(uint32_t{0})) << (32 - mask_bits);

data/src/core/lib/address_utils/sockaddr_utils.h

@@ -19,14 +19,14 @@
 #ifndef GRPC_SRC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H
 #define GRPC_SRC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <string>
 
 #include "absl/status/statusor.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/resolved_address.h"
 
 // Returns true if addr is an IPv4-mapped IPv6 address within the

data/src/core/lib/avl/avl.h

@@ -15,17 +15,17 @@
 #ifndef GRPC_SRC_CORE_LIB_AVL_AVL_H
 #define GRPC_SRC_CORE_LIB_AVL_AVL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdlib.h>
 
 #include <algorithm>  // IWYU pragma: keep
 #include <iterator>
 #include <utility>
 
-#include "src/core/lib/gpr/useful.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

data/src/core/lib/backoff/backoff.cc

@@ -16,12 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/backoff/backoff.h"
 
 #include <algorithm>
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 BackOff::BackOff(const Options& options) : options_(options) { Reset(); }

data/src/core/lib/backoff/backoff.h

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_BACKOFF_BACKOFF_H
 #define GRPC_SRC_CORE_LIB_BACKOFF_BACKOFF_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/random/random.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/time.h"
 
 namespace grpc_core {

data/src/core/lib/backoff/random_early_detection.cc

@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/backoff/random_early_detection.h"
 
 #include "absl/random/distributions.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 bool RandomEarlyDetection::Reject(uint64_t size, absl::BitGenRef bitsrc) const {