grpc 1.62.0 → 1.63.0

data/src/core/lib/gprpp/uuid_v4.cc

@@ -0,0 +1,37 @@
+//
+//
+// Copyright 2023 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>
+
+#include "src/core/lib/gprpp/uuid_v4.h"
+
+#include "absl/strings/str_format.h"
+
+namespace grpc_core {
+
+std::string GenerateUUIDv4(uint64_t hi, uint64_t lo) {
+  uint32_t time_low = hi >> 32;
+  uint16_t time_mid = hi >> 16;
+  uint16_t time_hi_and_version = (hi & 0x0fff) | 0x4000;
+  uint16_t clock_seq_hi_low = ((lo >> 48) & 0x3fff) | 0x8000;
+  uint64_t node = lo & 0xffffffffffff;
+  return absl::StrFormat("%08x-%04x-%04x-%04x-%012x", time_low, time_mid,
+                         time_hi_and_version, clock_seq_hi_low, node);
+}
+
+}  // namespace grpc_core

data/src/core/lib/gprpp/uuid_v4.h

@@ -0,0 +1,36 @@
+//
+//
+// Copyright 2023 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_SRC_CORE_LIB_GPRPP_UUID_V4_H
+#define GRPC_SRC_CORE_LIB_GPRPP_UUID_V4_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <string>
+
+namespace grpc_core {
+
+// Generates string in the UUIDv4 form. \a hi and \a lo are expected to be
+// random numbers.
+std::string GenerateUUIDv4(uint64_t hi, uint64_t lo);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_UUID_V4_H

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

@@ -30,6 +30,9 @@
 #endif
 #if defined(GPR_WINDOWS)
 #define GRPC_WINSOCK_SOCKET 1
+#ifndef __MINGW32__
+#define GRPC_HAVE_UNIX_SOCKET 1
+#endif  // __MINGW32__
 #define GRPC_WINDOWS_SOCKETUTILS 1
 #define GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER 1
 #elif defined(GPR_ANDROID)

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

@@ -145,6 +145,8 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   grpc_error_handle error;
   async_connect* ac = NULL;
   absl::StatusOr<std::string> addr_uri;
+  int addr_family;
+  int protocol;
 
   addr_uri = grpc_sockaddr_to_uri(addr);
   if (!addr_uri.ok()) {
@@ -159,14 +161,25 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
     addr = &addr6_v4mapped;
   }
 
-  sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  // extract family
+  addr_family =
+      (grpc_sockaddr_get_family(addr) == AF_UNIX) ? AF_UNIX : AF_INET6;
+  protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+
+  sock = WSASocket(addr_family, SOCK_STREAM, protocol, NULL, 0,
                    grpc_get_default_wsa_socket_flags());
   if (sock == INVALID_SOCKET) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");
     goto failure;
   }
 
-  error = grpc_tcp_prepare_socket(sock);
+  if (addr_family == AF_UNIX) {
+    // tcp settings for af_unix are skipped.
+    error = grpc_tcp_set_non_block(sock);
+  } else {
+    error = grpc_tcp_prepare_socket(sock);
+  }
+
   if (!error.ok()) {
     goto failure;
   }
@@ -183,7 +196,15 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
     goto failure;
   }
 
-  grpc_sockaddr_make_wildcard6(0, &local_address);
+  if (addr_family == AF_UNIX) {
+    // For ConnectEx() to work for AF_UNIX, the sock needs to be bound to
+    // the local address of an unnamed socket.
+    local_address = {};
+    ((grpc_sockaddr*)local_address.addr)->sa_family = AF_UNIX;
+    local_address.len = sizeof(grpc_sockaddr);
+  } else {
+    grpc_sockaddr_make_wildcard6(0, &local_address);
+  }
 
   status =
       bind(sock, (grpc_sockaddr*)&local_address.addr, (int)local_address.len);
@@ -196,7 +217,6 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   info = &socket->write_info;
   success = ConnectEx(sock, (grpc_sockaddr*)&addr->addr, (int)addr->len, NULL,
                       0, NULL, &info->overlapped);
-
   // It wouldn't be unusual to get a success immediately. But we'll still get
   // an IOCP notification, so let's ignore it.
   if (!success) {
@@ -206,7 +226,6 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
       goto failure;
     }
   }
-
   ac = new async_connect();
   ac->on_done = on_done;
   ac->socket = socket;

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

@@ -64,6 +64,7 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
@@ -562,6 +563,44 @@ struct backup_poller {
   grpc_closure run_poller;
 };
 
+void LogCommonIOErrors(absl::string_view prefix, int error_no) {
+  switch (error_no) {
+    case ECONNABORTED:
+      grpc_core::global_stats().IncrementEconnabortedCount();
+      return;
+    case ECONNRESET:
+      grpc_core::global_stats().IncrementEconnresetCount();
+      return;
+    case EPIPE:
+      grpc_core::global_stats().IncrementEpipeCount();
+      return;
+    case ETIMEDOUT:
+      grpc_core::global_stats().IncrementEtimedoutCount();
+      return;
+    case ECONNREFUSED:
+      grpc_core::global_stats().IncrementEconnrefusedCount();
+      return;
+    case ENETUNREACH:
+      grpc_core::global_stats().IncrementEnetunreachCount();
+      return;
+    case ENOMSG:
+      grpc_core::global_stats().IncrementEnomsgCount();
+      return;
+    case ENOTCONN:
+      grpc_core::global_stats().IncrementEnotconnCount();
+      return;
+    case ENOBUFS:
+      grpc_core::global_stats().IncrementEnobufsCount();
+      return;
+    default:
+      grpc_core::global_stats().IncrementUncommonIoErrorCount();
+      GRPC_LOG_EVERY_N_SEC(1, GPR_ERROR, "%s encountered uncommon error: %s",
+                           prefix.data(),
+                           grpc_core::StrError(error_no).c_str());
+      return;
+  }
+}
+
 }  // namespace
 
 static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp);
@@ -957,6 +996,9 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
     // We have read something in previous reads. We need to deliver those
     // bytes to the upper layer.
     if (read_bytes <= 0 && total_read_bytes >= 1) {
+      if (read_bytes < 0) {
+        LogCommonIOErrors("recvmsg", errno);
+      }
       tcp->inq = 1;
       break;
     }
@@ -1414,6 +1456,8 @@ static bool process_errors(grpc_tcp* tcp) {
       return processed_err;  // No more errors to process
     }
     if (r == -1) {
+      LogCommonIOErrors("recvmsg(MSG_ERRQUEUE)", saved_errno);
+      grpc_core::global_stats().IncrementMsgErrqueueErrorCount();
       return processed_err;
     }
     if (GPR_UNLIKELY((msg.msg_flags & MSG_CTRUNC) != 0)) {
@@ -1614,6 +1658,9 @@ static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
       grpc_fd_set_writable(tcp->em_fd);
     }
     if (sent_length < 0) {
+      if (saved_errno != EAGAIN) {
+        LogCommonIOErrors("sendmsg", saved_errno);
+      }
       // If this particular send failed, drop ref taken earlier in this method.
       tcp->tcp_zerocopy_send_ctx.UndoSend();
       if (saved_errno == EAGAIN || saved_errno == ENOBUFS) {

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

@@ -62,10 +62,6 @@
 #include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
 #include "src/core/lib/event_engine/shim.h"
-#include "src/core/lib/event_engine/tcp_socket_utils.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/iomgr/event_engine_shims/closure.h"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
@@ -79,7 +75,6 @@
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/iomgr/vsock.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/transport/error_utils.h"
 
 static std::atomic<int64_t> num_dropped_connections{0};
@@ -93,6 +88,24 @@ using ::grpc_event_engine::experimental::MemoryQuotaBasedMemoryAllocatorFactory;
 using ::grpc_event_engine::experimental::PosixEventEngineWithFdSupport;
 using ::grpc_event_engine::experimental::SliceBuffer;
 
+static void finish_shutdown(grpc_tcp_server* s) {
+  gpr_mu_lock(&s->mu);
+  GPR_ASSERT(s->shutdown);
+  gpr_mu_unlock(&s->mu);
+  if (s->shutdown_complete != nullptr) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, s->shutdown_complete,
+                            absl::OkStatus());
+  }
+  gpr_mu_destroy(&s->mu);
+  while (s->head) {
+    grpc_tcp_listener* sp = s->head;
+    s->head = sp->next;
+    gpr_free(sp);
+  }
+  delete s->fd_handler;
+  delete s;
+}
+
 static grpc_error_handle CreateEventEngineListener(
     grpc_tcp_server* s, grpc_closure* shutdown_complete,
     const EndpointConfig& config, grpc_tcp_server** server) {
@@ -117,63 +130,76 @@ static grpc_error_handle CreateEventEngineListener(
             SliceBuffer* pending_data) {
           grpc_core::ApplicationCallbackExecCtx app_ctx;
           grpc_core::ExecCtx exec_ctx;
-          grpc_tcp_server_acceptor* acceptor =
-              static_cast<grpc_tcp_server_acceptor*>(
-                  gpr_malloc(sizeof(*acceptor)));
-          acceptor->from_server = s;
-          acceptor->port_index = -1;
-          acceptor->fd_index = -1;
-          if (!is_external) {
-            auto it = s->listen_fd_to_index_map.find(listener_fd);
-            if (it != s->listen_fd_to_index_map.end()) {
-              acceptor->port_index = std::get<0>(it->second);
-              acceptor->fd_index = std::get<1>(it->second);
-            }
-          } else {
-            // External connection handling.
-            grpc_resolved_address addr;
-            memset(&addr, 0, sizeof(addr));
-            addr.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
-            // Get the fd of the socket connected to peer.
-            int fd =
-                reinterpret_cast<
-                    grpc_event_engine::experimental::PosixEndpoint*>(ep.get())
-                    ->GetWrappedFd();
-            if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
-                            &(addr.len)) < 0) {
-              gpr_log(GPR_ERROR, "Failed getpeername: %s",
-                      grpc_core::StrError(errno).c_str());
-              close(fd);
+          grpc_pollset* read_notifier_pollset;
+          grpc_tcp_server_acceptor* acceptor;
+          void* cb_arg;
+          // Scoped for server lock, to ensure it's released before the callback
+          // is called.
+          {
+            grpc_core::MutexLockForGprMu lock(&s->mu);
+            if (s->shutdown) {
               return;
             }
-            (void)grpc_set_socket_no_sigpipe_if_possible(fd);
-            auto addr_uri = grpc_sockaddr_to_uri(&addr);
-            if (!addr_uri.ok()) {
-              gpr_log(GPR_ERROR, "Invalid address: %s",
-                      addr_uri.status().ToString().c_str());
-              return;
+            cb_arg = s->on_accept_cb_arg;
+            acceptor = static_cast<grpc_tcp_server_acceptor*>(
+                gpr_malloc(sizeof(*acceptor)));
+            acceptor->from_server = s;
+            acceptor->port_index = -1;
+            acceptor->fd_index = -1;
+            if (!is_external) {
+              auto it = s->listen_fd_to_index_map.find(listener_fd);
+              if (it != s->listen_fd_to_index_map.end()) {
+                acceptor->port_index = std::get<0>(it->second);
+                acceptor->fd_index = std::get<1>(it->second);
+              }
+            } else {
+              // External connection handling.
+              grpc_resolved_address addr;
+              memset(&addr, 0, sizeof(addr));
+              addr.len =
+                  static_cast<socklen_t>(sizeof(struct sockaddr_storage));
+              // Get the fd of the socket connected to peer.
+              int fd =
+                  reinterpret_cast<
+                      grpc_event_engine::experimental::PosixEndpoint*>(ep.get())
+                      ->GetWrappedFd();
+              if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
+                              &(addr.len)) < 0) {
+                gpr_log(GPR_ERROR, "Failed getpeername: %s",
+                        grpc_core::StrError(errno).c_str());
+                close(fd);
+                return;
+              }
+              (void)grpc_set_socket_no_sigpipe_if_possible(fd);
+              auto addr_uri = grpc_sockaddr_to_uri(&addr);
+              if (!addr_uri.ok()) {
+                gpr_log(GPR_ERROR, "Invalid address: %s",
+                        addr_uri.status().ToString().c_str());
+                return;
+              }
+              if (grpc_tcp_trace.enabled()) {
+                gpr_log(GPR_INFO,
+                        "SERVER_CONNECT: incoming external connection: %s",
+                        addr_uri->c_str());
+              }
             }
-            if (grpc_tcp_trace.enabled()) {
-              gpr_log(GPR_INFO,
-                      "SERVER_CONNECT: incoming external connection: %s",
-                      addr_uri->c_str());
+            read_notifier_pollset =
+                (*(s->pollsets))[static_cast<size_t>(
+                                     gpr_atm_no_barrier_fetch_add(
+                                         &s->next_pollset_to_assign, 1)) %
+                                 s->pollsets->size()];
+            acceptor->external_connection = is_external;
+            acceptor->listener_fd = listener_fd;
+            grpc_byte_buffer* buf = nullptr;
+            if (pending_data != nullptr && pending_data->Length() > 0) {
+              buf = grpc_raw_byte_buffer_create(nullptr, 0);
+              grpc_slice_buffer_swap(&buf->data.raw.slice_buffer,
+                                     pending_data->c_slice_buffer());
+              pending_data->Clear();
             }
+            acceptor->pending_data = buf;
           }
-          grpc_pollset* read_notifier_pollset =
-              (*(s->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
-                                   &s->next_pollset_to_assign, 1)) %
-                               s->pollsets->size()];
-          acceptor->external_connection = is_external;
-          acceptor->listener_fd = listener_fd;
-          grpc_byte_buffer* buf = nullptr;
-          if (pending_data != nullptr && pending_data->Length() > 0) {
-            buf = grpc_raw_byte_buffer_create(nullptr, 0);
-            grpc_slice_buffer_swap(&buf->data.raw.slice_buffer,
-                                   pending_data->c_slice_buffer());
-            pending_data->Clear();
-          }
-          acceptor->pending_data = buf;
-          s->on_accept_cb(s->on_accept_cb_arg,
+          s->on_accept_cb(cb_arg,
                           grpc_event_engine::experimental::
                               grpc_event_engine_endpoint_create(std::move(ep)),
                           read_notifier_pollset, acceptor);
@@ -183,8 +209,7 @@ static grpc_error_handle CreateEventEngineListener(
         [s, shutdown_complete](absl::Status status) {
           grpc_event_engine::experimental::RunEventEngineClosure(
               shutdown_complete, absl_status_to_grpc_error(status));
-          delete s->fd_handler;
-          delete s;
+          finish_shutdown(s);
         },
         config,
         std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
@@ -194,7 +219,15 @@ static grpc_error_handle CreateEventEngineListener(
         [s](std::unique_ptr<EventEngine::Endpoint> ep, MemoryAllocator) {
           grpc_core::ApplicationCallbackExecCtx app_ctx;
           grpc_core::ExecCtx exec_ctx;
-          s->on_accept_cb(s->on_accept_cb_arg,
+          void* cb_arg;
+          {
+            grpc_core::MutexLockForGprMu lock(&s->mu);
+            if (s->shutdown) {
+              return;
+            }
+            cb_arg = s->on_accept_cb_arg;
+          }
+          s->on_accept_cb(cb_arg,
                           grpc_event_engine::experimental::
                               grpc_event_engine_endpoint_create(std::move(ep)),
                           nullptr, nullptr);
@@ -205,8 +238,7 @@ static grpc_error_handle CreateEventEngineListener(
           GPR_ASSERT(gpr_atm_no_barrier_load(&s->refs.count) == 0);
           grpc_event_engine::experimental::RunEventEngineClosure(
               shutdown_complete, absl_status_to_grpc_error(status));
-          delete s->fd_handler;
-          delete s;
+          finish_shutdown(s);
         },
         config,
         std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
@@ -271,30 +303,6 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   return absl::OkStatus();
 }
 
-static void finish_shutdown(grpc_tcp_server* s) {
-  gpr_mu_lock(&s->mu);
-  GPR_ASSERT(s->shutdown);
-  gpr_mu_unlock(&s->mu);
-  if (s->shutdown_complete != nullptr) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, s->shutdown_complete,
-                            absl::OkStatus());
-  }
-  gpr_mu_destroy(&s->mu);
-  while (s->head) {
-    grpc_tcp_listener* sp = s->head;
-    s->head = sp->next;
-    gpr_free(sp);
-  }
-  if (grpc_event_engine::experimental::UseEventEngineListener()) {
-    // This will trigger asynchronous execution of the on_shutdown_complete
-    // callback when appropriate. That callback will delete the server
-    s->ee_listener.reset();
-  } else {
-    delete s->fd_handler;
-    delete s;
-  }
-}
-
 static void destroyed_port(void* server, grpc_error_handle /*error*/) {
   grpc_tcp_server* s = static_cast<grpc_tcp_server*>(server);
   gpr_mu_lock(&s->mu);
@@ -332,7 +340,13 @@ static void deactivated_all_ports(grpc_tcp_server* s) {
     gpr_mu_unlock(&s->mu);
   } else {
     gpr_mu_unlock(&s->mu);
-    finish_shutdown(s);
+    if (grpc_event_engine::experimental::UseEventEngineListener()) {
+      // This will trigger asynchronous execution of the on_shutdown_complete
+      // callback when appropriate. That callback will delete the server.
+      s->ee_listener.reset();
+    } else {
+      finish_shutdown(s);
+    }
   }
 }
 

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

@@ -78,13 +78,21 @@ using ::grpc_event_engine::experimental::WindowsEventEngineListener;
 // one listening port
 typedef struct grpc_tcp_listener grpc_tcp_listener;
 struct grpc_tcp_listener {
+  // Buffer to hold the local and remote address.
   // This seemingly magic number comes from AcceptEx's documentation. each
   // address buffer needs to have at least 16 more bytes at their end.
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  // unix addr is larger than ip addr.
+  uint8_t addresses[(sizeof(sockaddr_un) + 16) * 2] = {};
+#else
   uint8_t addresses[(sizeof(grpc_sockaddr_in6) + 16) * 2];
+#endif  // GRPC_HAVE_UNIX_SOCKET
   // This will hold the socket for the next accept.
   SOCKET new_socket;
   // The listener winsocket.
   grpc_winsocket* socket;
+  // address of listener
+  grpc_resolved_address resolved_addr;
   // The actual TCP port number.
   int port;
   unsigned port_index;
@@ -125,6 +133,35 @@ struct grpc_tcp_server {
   WindowsEventEngineListener* ee_listener;
 };
 
+// TODO(hork): This may be refactored to share with posix engine and event
+// engine.
+void unlink_if_unix_domain_socket(const grpc_resolved_address* resolved_addr) {
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (addr->sa_family != AF_UNIX) {
+    return;
+  }
+  struct sockaddr_un* un =
+      reinterpret_cast<struct sockaddr_un*>(const_cast<sockaddr*>(addr));
+  // There is nothing to unlink for an abstract unix socket.
+  if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
+    return;
+  }
+  // For windows we need to remove the file instead of unlink.
+  DWORD attr = ::GetFileAttributesA(un->sun_path);
+  if (attr == INVALID_FILE_ATTRIBUTES) {
+    return;
+  }
+  if (attr & FILE_ATTRIBUTE_DIRECTORY || attr & FILE_ATTRIBUTE_READONLY) {
+    return;
+  }
+  ::DeleteFileA(un->sun_path);
+#else
+  (void)resolved_addr;
+#endif
+}
+
 // Public function. Allocates the proper data structures to hold a
 // grpc_tcp_server.
 static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
@@ -158,6 +195,7 @@ static void destroy_server(void* arg, grpc_error_handle /* error */) {
     s->head = sp->next;
     sp->next = NULL;
     grpc_winsocket_destroy(sp->socket);
+    unlink_if_unix_domain_socket(&sp->resolved_addr);
     gpr_free(sp);
   }
   gpr_mu_destroy(&s->mu);
@@ -222,12 +260,15 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   grpc_resolved_address sockname_temp;
   grpc_error_handle error;
   int sockname_temp_len;
-
-  error = grpc_tcp_prepare_socket(sock);
+  if (grpc_sockaddr_get_family(addr) == AF_UNIX) {
+    error = grpc_tcp_set_non_block(sock);
+  } else {
+    error = grpc_tcp_prepare_socket(sock);
+  }
   if (!error.ok()) {
     goto failure;
   }
-
+  unlink_if_unix_domain_socket(addr);
   if (bind(sock, (const grpc_sockaddr*)addr->addr, (int)addr->len) ==
       SOCKET_ERROR) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "bind");
@@ -277,22 +318,28 @@ static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
 static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
-  DWORD addrlen = sizeof(grpc_sockaddr_in6) + 16;
+  const DWORD addrlen = sizeof(port->addresses) / 2;
   DWORD bytes_received = 0;
   grpc_error_handle error;
 
   if (port->shutting_down) {
     return absl::OkStatus();
   }
-
-  sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  const int addr_family =
+      grpc_sockaddr_get_family(&port->resolved_addr) == AF_UNIX ? AF_UNIX
+                                                                : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  sock = WSASocket(addr_family, SOCK_STREAM, protocol, NULL, 0,
                    grpc_get_default_wsa_socket_flags());
   if (sock == INVALID_SOCKET) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");
     goto failure;
   }
-
-  error = grpc_tcp_prepare_socket(sock);
+  if (addr_family == AF_UNIX) {
+    error = grpc_tcp_set_non_block(sock);
+  } else {
+    error = grpc_tcp_prepare_socket(sock);
+  }
   if (!error.ok()) goto failure;
 
   // Start the "accept" asynchronously.
@@ -463,6 +510,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   sp->outstanding_calls = 0;
   sp->AcceptEx = AcceptEx;
   sp->new_socket = INVALID_SOCKET;
+  sp->resolved_addr = *addr;
   sp->port = port;
   sp->port_index = port_index;
   GRPC_CLOSURE_INIT(&sp->on_accept, on_accept, sp, grpc_schedule_on_exec_ctx);
@@ -522,7 +570,10 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
     addr = &wildcard;
   }
 
-  sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  const int addr_family =
+      grpc_sockaddr_get_family(addr) == AF_UNIX ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  sock = WSASocket(addr_family, SOCK_STREAM, protocol, NULL, 0,
                    grpc_get_default_wsa_socket_flags());
   if (sock == INVALID_SOCKET) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");

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

@@ -24,7 +24,14 @@
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#ifdef GPR_WINDOWS
+// clang-format off
+#include <ws2def.h>
+#include <afunix.h>
+// clang-format on
+#else
 #include <sys/un.h>
+#endif  // GPR_WINDOWS
 
 #include "absl/strings/str_cat.h"
 
@@ -39,7 +46,11 @@
 #include "src/core/lib/transport/error_utils.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
+#ifdef GPR_WINDOWS
+  grpc_core::Crash("AF_UNIX socket pairs are not supported on Windows");
+#else
   GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+#endif
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>
@@ -86,10 +97,12 @@ void grpc_unlink_if_unix_domain_socket(
     return;
   }
 
+#ifndef GPR_WINDOWS
   struct stat st;
   if (stat(un->sun_path, &st) == 0 && (st.st_mode & S_IFMT) == S_IFSOCK) {
     unlink(un->sun_path);
   }
+#endif
 }
 
 #endif

data/src/core/lib/promise/activity.h

@@ -31,6 +31,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/orphanable.h"