grpc 1.46.3-x86_64-linux → 1.47.0-x86_64-linux

data/src/core/lib/http/httpcli.cc

@@ -20,6 +20,7 @@
 
 #include "src/core/lib/http/httpcli.h"
 
+#include <limits.h>
 #include <string.h>
 
 #include <string>
@@ -46,6 +47,7 @@
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
 
 namespace grpc_core {
 
@@ -53,6 +55,7 @@ namespace {
 
 grpc_httpcli_get_override g_get_override;
 grpc_httpcli_post_override g_post_override;
+grpc_httpcli_put_override g_put_override;
 void (*g_test_only_on_handshake_done_intercept)(HttpRequest* req);
 
 }  // namespace
@@ -107,10 +110,36 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
       std::move(channel_creds));
 }
 
+OrphanablePtr<HttpRequest> HttpRequest::Put(
+    URI uri, const grpc_channel_args* channel_args,
+    grpc_polling_entity* pollent, const grpc_http_request* request,
+    Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
+    RefCountedPtr<grpc_channel_credentials> channel_creds) {
+  absl::optional<std::function<void()>> test_only_generate_response;
+  if (g_put_override != nullptr) {
+    test_only_generate_response = [request, uri, deadline, on_done,
+                                   response]() {
+      g_put_override(request, uri.authority().c_str(), uri.path().c_str(),
+                     request->body, request->body_length, deadline, on_done,
+                     response);
+    };
+  }
+  std::string name =
+      absl::StrFormat("HTTP:PUT:%s:%s", uri.authority(), uri.path());
+  const grpc_slice request_text = grpc_httpcli_format_put_request(
+      request, uri.authority().c_str(), uri.path().c_str());
+  return MakeOrphanable<HttpRequest>(
+      std::move(uri), request_text, response, deadline, channel_args, on_done,
+      pollent, name.c_str(), std::move(test_only_generate_response),
+      std::move(channel_creds));
+}
+
 void HttpRequest::SetOverride(grpc_httpcli_get_override get,
-                              grpc_httpcli_post_override post) {
+                              grpc_httpcli_post_override post,
+                              grpc_httpcli_put_override put) {
   g_get_override = get;
   g_post_override = post;
+  g_put_override = put;
 }
 
 void HttpRequest::TestOnlySetOnHandshakeDoneIntercept(
@@ -129,7 +158,8 @@ HttpRequest::HttpRequest(
       deadline_(deadline),
       channel_args_(CoreConfiguration::Get()
                         .channel_args_preconditioning()
-                        .PreconditionChannelArgs(channel_args)),
+                        .PreconditionChannelArgs(channel_args)
+                        .ToC()),
       channel_creds_(std::move(channel_creds)),
       on_done_(on_done),
       resource_quota_(ResourceQuotaFromChannelArgs(channel_args_)),
@@ -150,10 +180,6 @@ HttpRequest::HttpRequest(
                     grpc_schedule_on_exec_ctx);
   GPR_ASSERT(pollent);
   grpc_polling_entity_add_to_pollset_set(pollent, pollset_set_);
-  // Create the DNS resolver. We'll start resolving when Start is called.
-  dns_request_ = GetDNSResolver()->ResolveName(
-      uri_.authority(), uri_.scheme(), pollset_set_,
-      absl::bind_front(&HttpRequest::OnResolved, this));
 }
 
 HttpRequest::~HttpRequest() {
@@ -177,7 +203,9 @@ void HttpRequest::Start() {
     return;
   }
   Ref().release();  // ref held by pending DNS resolution
-  dns_request_->Start();
+  dns_request_handle_ = GetDNSResolver()->ResolveName(
+      uri_.authority(), uri_.scheme(), pollset_set_,
+      absl::bind_front(&HttpRequest::OnResolved, this));
 }
 
 void HttpRequest::Orphan() {
@@ -185,21 +213,17 @@ void HttpRequest::Orphan() {
     MutexLock lock(&mu_);
     GPR_ASSERT(!cancelled_);
     cancelled_ = true;
-    dns_request_.reset();  // cancel potentially pending DNS resolution
-    if (connecting_) {
-      // gRPC's TCP connection establishment API doesn't currently have
-      // a mechanism for cancellation. So invoke the user callback now. The TCP
-      // connection will eventually complete (at least within its deadline), and
-      // we'll simply unref ourselves at that point.
-      // TODO(apolcyn): fix this to cancel the TCP connection attempt when
-      // an API to do so exists.
-      Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-          "HTTP request cancelled during TCP connection establishment",
-          &overall_error_, 1));
+    // cancel potentially pending DNS resolution.
+    if (dns_request_handle_.has_value() &&
+        GetDNSResolver()->Cancel(dns_request_handle_.value())) {
+      Finish(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "cancelled during DNS resolution"));
+      Unref();
     }
     if (handshake_mgr_ != nullptr) {
+      // Shutdown will cancel any ongoing tcp connect.
       handshake_mgr_->Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "HTTP request cancelled during security handshake"));
+          "HTTP request cancelled during handshake"));
     }
     if (own_endpoint_ && ep_ != nullptr) {
       grpc_endpoint_shutdown(
@@ -215,10 +239,12 @@ void HttpRequest::AppendError(grpc_error_handle error) {
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
   const grpc_resolved_address* addr = &addresses_[next_address_ - 1];
-  std::string addr_text = grpc_sockaddr_to_uri(addr);
+  auto addr_text = grpc_sockaddr_to_uri(addr);
   overall_error_ = grpc_error_add_child(
       overall_error_,
-      grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_text));
+      grpc_error_set_str(
+          error, GRPC_ERROR_STR_TARGET_ADDRESS,
+          addr_text.ok() ? addr_text.value() : addr_text.status().ToString()));
 }
 
 void HttpRequest::OnReadInternal(grpc_error_handle error) {
@@ -260,7 +286,8 @@ void HttpRequest::StartWrite() {
   grpc_slice_ref_internal(request_text_);
   grpc_slice_buffer_add(&outgoing_, request_text_);
   Ref().release();  // ref held by pending write
-  grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr);
+  grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr,
+                      /*max_frame_size=*/INT_MAX);
 }
 
 void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
@@ -274,8 +301,7 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
   MutexLock lock(&req->mu_);
   req->own_endpoint_ = true;
   if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR, "Secure transport setup failed: %s",
-            grpc_error_std_string(error).c_str());
+    req->handshake_mgr_.reset();
     req->NextAddress(GRPC_ERROR_REF(error));
     return;
   }
@@ -284,69 +310,55 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
   grpc_slice_buffer_destroy_internal(args->read_buffer);
   gpr_free(args->read_buffer);
   req->ep_ = args->endpoint;
+  req->handshake_mgr_.reset();
   if (req->cancelled_) {
     req->NextAddress(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "HTTP request cancelled during security handshake"));
+        "HTTP request cancelled during handshake"));
     return;
   }
   req->StartWrite();
 }
 
-void HttpRequest::OnConnected(void* arg, grpc_error_handle error) {
-  RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(arg));
-  MutexLock lock(&req->mu_);
-  req->connecting_ = false;
-  req->own_endpoint_ = true;
-  if (req->cancelled_) {
-    // since we were cancelled while connecting, Finish has already
-    // been called.
-    return;
-  }
-  if (!req->ep_) {
-    req->NextAddress(GRPC_ERROR_REF(error));
-    return;
-  }
-  // TODO(yihuaz): treating nullptr channel_creds_ as insecure is
-  // a hack used to support the port server client (a test utility) in
-  // unsecure builds (when no definition of grpc_insecure_credentials_create
-  // exists). We can remove this hack and unconditionally assume a valid
-  // channel_creds_ object after unsecure builds are deleted, in
-  // https://github.com/grpc/grpc/pull/25586.
-  if (req->channel_creds_ == nullptr) {
-    gpr_log(GPR_DEBUG,
-            "HTTP request skipping handshake because creds are null");
-    req->StartWrite();
-    return;
-  }
+void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
   // Create the security connector using the credentials and target name.
   grpc_channel_args* new_args_from_connector = nullptr;
   RefCountedPtr<grpc_channel_security_connector> sc =
-      req->channel_creds_->create_security_connector(
-          nullptr /*call_creds*/, req->uri_.authority().c_str(),
-          req->channel_args_, &new_args_from_connector);
+      channel_creds_->create_security_connector(
+          nullptr /*call_creds*/, uri_.authority().c_str(), channel_args_,
+          &new_args_from_connector);
   if (sc == nullptr) {
-    req->Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-        "failed to create security connector", &req->overall_error_, 1));
+    Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "failed to create security connector", &overall_error_, 1));
     return;
   }
-  grpc_arg security_connector_arg = grpc_security_connector_to_arg(sc.get());
-  grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
+  absl::StatusOr<std::string> address = grpc_sockaddr_to_uri(addr);
+  if (!address.ok()) {
+    Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "Failed to extract URI from address", &overall_error_, 1));
+    return;
+  }
+  absl::InlinedVector<grpc_arg, 2> args_to_add = {
+      grpc_security_connector_to_arg(sc.get()),
+      grpc_channel_arg_string_create(
+          const_cast<char*>(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS),
+          const_cast<char*>(address.value().c_str())),
+  };
+  const grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
       new_args_from_connector != nullptr ? new_args_from_connector
-                                         : req->channel_args_,
-      &security_connector_arg, 1);
+                                         : channel_args_,
+      args_to_add.data(), args_to_add.size());
   grpc_channel_args_destroy(new_args_from_connector);
   // Start the handshake
-  req->handshake_mgr_ = MakeRefCounted<HandshakeManager>();
+  handshake_mgr_ = MakeRefCounted<HandshakeManager>();
   CoreConfiguration::Get().handshaker_registry().AddHandshakers(
-      HANDSHAKER_CLIENT, new_args, req->pollset_set_,
-      req->handshake_mgr_.get());
-  req->Ref().release();  // ref held by pending handshake
-  grpc_endpoint* ep = req->ep_;
-  req->ep_ = nullptr;
-  req->own_endpoint_ = false;
-  req->handshake_mgr_->DoHandshake(ep, new_args, req->deadline_,
-                                   /*acceptor=*/nullptr, OnHandshakeDone,
-                                   /*user_data=*/req.get());
+      HANDSHAKER_CLIENT, new_args, pollset_set_, handshake_mgr_.get());
+  Ref().release();  // ref held by pending handshake
+  grpc_endpoint* ep = ep_;
+  ep_ = nullptr;
+  own_endpoint_ = false;
+  handshake_mgr_->DoHandshake(ep, new_args, deadline_,
+                              /*acceptor=*/nullptr, OnHandshakeDone,
+                              /*user_data=*/this);
   sc.reset(DEBUG_LOCATION, "httpcli");
   grpc_channel_args_destroy(new_args);
 }
@@ -366,28 +378,23 @@ void HttpRequest::NextAddress(grpc_error_handle error) {
     return;
   }
   const grpc_resolved_address* addr = &addresses_[next_address_++];
-  GRPC_CLOSURE_INIT(&connected_, OnConnected, this, grpc_schedule_on_exec_ctx);
-  connecting_ = true;
-  own_endpoint_ = false;
-  Ref().release();  // ref held by pending connect
-  grpc_tcp_client_connect(&connected_, &ep_, pollset_set_, channel_args_, addr,
-                          deadline_);
+  DoHandshake(addr);
 }
 
 void HttpRequest::OnResolved(
     absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
   RefCountedPtr<HttpRequest> unreffer(this);
   MutexLock lock(&mu_);
-  dns_request_.reset();
-  if (!addresses_or.ok()) {
-    Finish(absl_status_to_grpc_error(addresses_or.status()));
-    return;
-  }
+  dns_request_handle_.reset();
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "cancelled during DNS resolution"));
     return;
   }
+  if (!addresses_or.ok()) {
+    Finish(absl_status_to_grpc_error(addresses_or.status()));
+    return;
+  }
   addresses_ = std::move(*addresses_or);
   next_address_ = 0;
   NextAddress(GRPC_ERROR_NONE);

data/src/core/lib/http/httpcli.h

@@ -25,7 +25,6 @@
 
 #include <grpc/support/time.h>
 
-#include "src/core/lib/channel/handshaker.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -35,6 +34,7 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/transport/handshaker.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 /* User agent this library reports */
@@ -50,6 +50,10 @@ typedef int (*grpc_httpcli_post_override)(
     const grpc_http_request* request, const char* host, const char* path,
     const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
     grpc_closure* on_complete, grpc_http_response* response);
+typedef int (*grpc_httpcli_put_override)(
+    const grpc_http_request* request, const char* host, const char* path,
+    const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
+    grpc_closure* on_complete, grpc_http_response* response);
 
 namespace grpc_core {
 
@@ -112,6 +116,32 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
       RefCountedPtr<grpc_channel_credentials> channel_creds)
       GRPC_MUST_USE_RESULT;
 
+  // Asynchronously perform a HTTP PUT.
+  // 'uri' is the target to make the request to. The scheme field is used to
+  //  determine the port number. The authority field is the target host. The
+  //  path field determines the path of the request. No other fields are used.
+  // 'args' are optional channel args for the request.
+  // 'pollent' indicates a grpc_polling_entity that is interested in the result
+  //   of the post - work on this entity may be used to progress the post
+  //   operation
+  // 'request' contains request parameters - these are caller owned and can be
+  //   destroyed once the call returns
+  // 'deadline' contains a deadline for the request (or gpr_inf_future)
+  // 'on_done' is a callback to report results to
+  // 'channel_creds' are used to configurably secure the connection.
+  //   For insecure requests, use grpc_insecure_credentials_create.
+  //   For secure requests, use CreateHttpRequestSSLCredentials().
+  //   nullptr is treated as insecure credentials.
+  //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
+  //   are removed.
+  // Does not support ?var1=val1&var2=val2 in the path.
+  static OrphanablePtr<HttpRequest> Put(
+      URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
+      const grpc_http_request* request, Timestamp deadline,
+      grpc_closure* on_done, grpc_http_response* response,
+      RefCountedPtr<grpc_channel_credentials> channel_creds)
+      GRPC_MUST_USE_RESULT;
+
   HttpRequest(URI uri, const grpc_slice& request_text,
               grpc_http_response* response, Timestamp deadline,
               const grpc_channel_args* channel_args, grpc_closure* on_done,
@@ -126,7 +156,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   void Orphan() override;
 
   static void SetOverride(grpc_httpcli_get_override get,
-                          grpc_httpcli_post_override post);
+                          grpc_httpcli_post_override post,
+                          grpc_httpcli_put_override put);
 
   static void TestOnlySetOnHandshakeDoneIntercept(
       void (*intercept)(HttpRequest* req));
@@ -141,7 +172,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
   void DoRead() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     Ref().release();  // ref held by pending read
-    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true);
+    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true,
+                       /*min_progress_size=*/1);
   }
 
   static void OnRead(void* user_data, grpc_error_handle error) {
@@ -179,7 +211,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
   static void OnHandshakeDone(void* arg, grpc_error_handle error);
 
-  static void OnConnected(void* arg, grpc_error_handle error);
+  void DoHandshake(const grpc_resolved_address* addr)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   void NextAddress(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
@@ -195,7 +228,6 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   grpc_closure continue_on_read_after_schedule_on_exec_ctx_;
   grpc_closure done_write_;
   grpc_closure continue_done_write_after_schedule_on_exec_ctx_;
-  grpc_closure connected_;
   grpc_endpoint* ep_ = nullptr;
   grpc_closure* on_done_;
   ResourceQuotaRefPtr resource_quota_;
@@ -206,7 +238,6 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
   bool own_endpoint_ ABSL_GUARDED_BY(mu_) = true;
   bool cancelled_ ABSL_GUARDED_BY(mu_) = false;
-  bool connecting_ ABSL_GUARDED_BY(mu_) = false;
   grpc_http_parser parser_ ABSL_GUARDED_BY(mu_);
   std::vector<grpc_resolved_address> addresses_ ABSL_GUARDED_BY(mu_);
   size_t next_address_ ABSL_GUARDED_BY(mu_) = 0;
@@ -215,7 +246,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   grpc_slice_buffer incoming_ ABSL_GUARDED_BY(mu_);
   grpc_slice_buffer outgoing_ ABSL_GUARDED_BY(mu_);
   grpc_error_handle overall_error_ ABSL_GUARDED_BY(mu_) = GRPC_ERROR_NONE;
-  OrphanablePtr<DNSResolver::Request> dns_request_ ABSL_GUARDED_BY(mu_);
+  absl::optional<DNSResolver::TaskHandle> dns_request_handle_
+      ABSL_GUARDED_BY(mu_) = DNSResolver::kNullHandle;
 };
 
 }  // namespace grpc_core

data/src/core/lib/http/httpcli_security_connector.cc

@@ -178,12 +178,11 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
     return Ref();
   }
 
-  grpc_channel_args* update_arguments(grpc_channel_args* args) override {
-    return args;
+  UniqueTypeName type() const override {
+    static UniqueTypeName::Factory kFactory("HttpRequestSSL");
+    return kFactory.Create();
   }
 
-  const char* type() const override { return "HttpRequestSSL"; }
-
  private:
   int cmp_impl(const grpc_channel_credentials* /* other */) const override {
     // There's no differentiating factor between two HttpRequestSSLCredentials

data/src/core/lib/iomgr/endpoint.cc

@@ -23,13 +23,13 @@
 grpc_core::TraceFlag grpc_tcp_trace(false, "tcp");
 
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb, bool urgent) {
-  ep->vtable->read(ep, slices, cb, urgent);
+                        grpc_closure* cb, bool urgent, int min_progress_size) {
+  ep->vtable->read(ep, slices, cb, urgent, min_progress_size);
 }
 
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, void* arg) {
-  ep->vtable->write(ep, slices, cb, arg);
+                         grpc_closure* cb, void* arg, int max_frame_size) {
+  ep->vtable->write(ep, slices, cb, arg, max_frame_size);
 }
 
 void grpc_endpoint_add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {

data/src/core/lib/iomgr/endpoint.h

@@ -38,9 +38,9 @@ typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
 
 struct grpc_endpoint_vtable {
   void (*read)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-               bool urgent);
+               bool urgent, int min_progress_size);
   void (*write)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-                void* arg);
+                void* arg, int max_frame_size);
   void (*add_to_pollset)(grpc_endpoint* ep, grpc_pollset* pollset);
   void (*add_to_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
   void (*delete_from_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
@@ -58,7 +58,7 @@ struct grpc_endpoint_vtable {
    Valid slices may be placed into \a slices even when the callback is
    invoked with error != GRPC_ERROR_NONE. */
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb, bool urgent);
+                        grpc_closure* cb, bool urgent, int min_progress_size);
 
 absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep);
 
@@ -79,9 +79,11 @@ int grpc_endpoint_get_fd(grpc_endpoint* ep);
    it is a valid slice buffer.
    \a arg is platform specific. It is currently only used by TCP on linux
    platforms as an argument that would be forwarded to the timestamps callback.
+   \a max_frame_size. A hint to the endpoint implementation to construct
+   frames which do not exceed the specified size.
    */
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, void* arg);
+                         grpc_closure* cb, void* arg, int max_frame_size);
 
 /* Causes any pending and future read/write callbacks to run immediately with
    success==0 */

data/src/core/lib/iomgr/endpoint_cfstream.cc

@@ -237,7 +237,8 @@ static void WriteAction(void* arg, grpc_error_handle error) {
 }
 
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, bool urgent) {
+                         grpc_closure* cb, bool urgent,
+                         int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p read (%p, %p) length:%zu", ep_impl,
@@ -254,7 +255,7 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                          grpc_closure* cb, void* arg) {
+                          grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
@@ -351,11 +352,13 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
   if (native_handle) {
     CFRelease(native_handle);
   }
+  absl::StatusOr<std::string> addr_uri;
   if (getsockname(sockfd, reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
+                  &resolved_local_addr.len) < 0 ||
+      !(addr_uri = grpc_sockaddr_to_uri(&resolved_local_addr)).ok()) {
     ep_impl->local_address = "";
   } else {
-    ep_impl->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+    ep_impl->local_address = addr_uri.value();
   }
   ep_impl->read_cb = nil;
   ep_impl->write_cb = nil;

data/src/core/lib/iomgr/endpoint_pair_posix.cc

@@ -62,7 +62,8 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   std::string final_name = absl::StrCat(name, ":client");
   const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
                                           .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args);
+                                          .PreconditionChannelArgs(args)
+                                          .ToC();
   p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
                              new_args, "socketpair-server");
   final_name = absl::StrCat(name, ":server");

data/src/core/lib/iomgr/ev_posix.cc

@@ -237,10 +237,7 @@ void grpc_event_engine_shutdown(void) {
 
 bool grpc_event_engine_can_track_errors(void) {
   /* Only track errors if platform supports errqueue. */
-  if (grpc_core::kernel_supports_errqueue()) {
-    return g_event_engine->can_track_err;
-  }
-  return false;
+  return grpc_core::KernelSupportsErrqueue() && g_event_engine->can_track_err;
 }
 
 bool grpc_event_engine_run_in_background(void) {

data/src/core/lib/iomgr/exec_ctx.h

@@ -204,8 +204,6 @@ class ExecCtx {
   /** Gets pointer to current exec_ctx. */
   static ExecCtx* Get() { return exec_ctx_; }
 
-  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
-
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
 
@@ -220,6 +218,7 @@ class ExecCtx {
 
  private:
   /** Set exec_ctx_ to exec_ctx. */
+  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
   CombinerData combiner_data_ = {nullptr, nullptr};

data/src/core/lib/iomgr/internal_errqueue.cc

@@ -1,20 +1,16 @@
-/*
- *
- * 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.
 
 #include <grpc/support/port_platform.h>
 
@@ -32,37 +28,32 @@
 #include <sys/utsname.h>
 
 namespace grpc_core {
-static bool errqueue_supported = false;
 
-bool kernel_supports_errqueue() { return errqueue_supported; }
-
-void grpc_errqueue_init() {
-/* Both-compile time and run-time linux kernel versions should be at least 4.0.0
- */
+bool KernelSupportsErrqueue() {
+  static const bool errqueue_supported = []() {
 #ifdef GRPC_LINUX_ERRQUEUE
-  struct utsname buffer;
-  if (uname(&buffer) != 0) {
-    gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
-    return;
-  }
-  char* release = buffer.release;
-  if (release == nullptr) {
-    return;
-  }
-
-  if (strtol(release, nullptr, 10) >= 4) {
-    errqueue_supported = true;
-  } else {
-    gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
-  }
-#endif /* GRPC_LINUX_ERRQUEUE */
+    // Both-compile time and run-time linux kernel versions should be at
+    // least 4.0.0
+    struct utsname buffer;
+    if (uname(&buffer) != 0) {
+      gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
+      return false;
+    }
+    char* release = buffer.release;
+    if (release == nullptr) {
+      return false;
+    }
+
+    if (strtol(release, nullptr, 10) >= 4) {
+      return true;
+    } else {
+      gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
+    }
+#endif  // GRPC_LINUX_ERRQUEUE
+    return false;
+  }();
+  return errqueue_supported;
 }
-} /* namespace grpc_core */
-
-#else
-
-namespace grpc_core {
-void grpc_errqueue_init() {}
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
-#endif /* GRPC_POSIX_SOCKET_TCP */
+#endif  // GRPC_POSIX_SOCKET_TCP