grpc 1.52.0 → 1.53.0

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.cc

@@ -14,6 +14,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -46,7 +47,7 @@ namespace grpc_event_engine {
 namespace experimental {
 
 PosixEngineListenerImpl::PosixEngineListenerImpl(
-    EventEngine::Listener::AcceptCallback on_accept,
+    PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const grpc_event_engine::experimental::EndpointConfig& config,
     std::unique_ptr<grpc_event_engine::experimental::MemoryAllocatorFactory>
@@ -61,7 +62,8 @@ PosixEngineListenerImpl::PosixEngineListenerImpl(
       memory_allocator_factory_(std::move(memory_allocator_factory)) {}
 
 absl::StatusOr<int> PosixEngineListenerImpl::Bind(
-    const EventEngine::ResolvedAddress& addr) {
+    const EventEngine::ResolvedAddress& addr,
+    PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_bind_new_fd) {
   EventEngine::ResolvedAddress res_addr = addr;
   EventEngine::ResolvedAddress addr6_v4mapped;
   int requested_port = ResolvedAddressGetPort(res_addr);
@@ -89,6 +91,9 @@ absl::StatusOr<int> PosixEngineListenerImpl::Bind(
   }
 
   auto used_port = ResolvedAddressIsWildcard(res_addr);
+  // Update the callback. Any subsequent new sockets created and added to
+  // acceptors_ in this function will invoke the new callback.
+  acceptors_.UpdateOnAppendCallback(std::move(on_bind_new_fd));
   if (used_port.has_value()) {
     requested_port = *used_port;
     return ListenerContainerAddWildcardAddresses(acceptors_, options_,
@@ -155,6 +160,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
         Unref();
         return;
       }
+      addr = EventEngine::ResolvedAddress(addr.address(), len);
     }
 
     PosixSocketWrapper sock(fd);
@@ -171,25 +177,72 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     }
 
     // Create an Endpoint here.
-    std::string peer_name = *ResolvedAddressToNormalizedString(addr);
+    auto peer_name = ResolvedAddressToURI(addr);
+    if (!peer_name.ok()) {
+      gpr_log(GPR_ERROR, "Invalid address: %s",
+              peer_name.status().ToString().c_str());
+      // Shutting down the acceptor. Unref the ref grabbed in
+      // AsyncConnectionAcceptor::Start().
+      Unref();
+      return;
+    }
     auto endpoint = CreatePosixEndpoint(
         /*handle=*/listener_->poller_->CreateHandle(
-            fd, peer_name, listener_->poller_->CanTrackErrors()),
+            fd, *peer_name, listener_->poller_->CanTrackErrors()),
         /*on_shutdown=*/nullptr, /*engine=*/listener_->engine_,
         // allocator=
         listener_->memory_allocator_factory_->CreateMemoryAllocator(
-            absl::StrCat("endpoint-tcp-server-connection: ", peer_name)),
+            absl::StrCat("endpoint-tcp-server-connection: ", *peer_name)),
         /*options=*/listener_->options_);
     // Call on_accept_ and then resume accepting new connections by continuing
     // the parent for-loop.
     listener_->on_accept_(
-        std::move(endpoint),
+        /*listener_fd=*/handle_->WrappedFd(), /*endpoint=*/std::move(endpoint),
+        /*is_external=*/false,
+        /*memory_allocator=*/
         listener_->memory_allocator_factory_->CreateMemoryAllocator(
-            absl::StrCat("on-accept-tcp-server-connection: ", peer_name)));
+            absl::StrCat("on-accept-tcp-server-connection: ", *peer_name)),
+        /*pending_data=*/nullptr);
   }
   GPR_UNREACHABLE_CODE(return);
 }
 
+absl::Status PosixEngineListenerImpl::HandleExternalConnection(
+    int listener_fd, int fd, SliceBuffer* pending_data) {
+  if (listener_fd < 0) {
+    return absl::UnknownError(absl::StrCat(
+        "HandleExternalConnection: Invalid listener socket: ", listener_fd));
+  }
+  if (fd < 0) {
+    return absl::UnknownError(
+        absl::StrCat("HandleExternalConnection: Invalid peer socket: ", fd));
+  }
+  PosixSocketWrapper sock(fd);
+  (void)sock.SetSocketNoSigpipeIfPossible();
+  auto peer_name = sock.PeerAddressString();
+  if (!peer_name.ok()) {
+    return absl::UnknownError(
+        absl::StrCat("HandleExternalConnection: peer not connected: ",
+                     peer_name.status().ToString()));
+  }
+  auto endpoint = CreatePosixEndpoint(
+      /*handle=*/poller_->CreateHandle(fd, *peer_name,
+                                       poller_->CanTrackErrors()),
+      /*on_shutdown=*/nullptr, /*engine=*/engine_,
+      /*allocator=*/
+      memory_allocator_factory_->CreateMemoryAllocator(absl::StrCat(
+          "external:endpoint-tcp-server-connection: ", *peer_name)),
+      /*options=*/options_);
+  on_accept_(
+      /*listener_fd=*/listener_fd, /*endpoint=*/std::move(endpoint),
+      /*is_external=*/true,
+      /*memory_allocator=*/
+      memory_allocator_factory_->CreateMemoryAllocator(absl::StrCat(
+          "external:on-accept-tcp-server-connection: ", *peer_name)),
+      /*pending_data=*/pending_data);
+  return absl::OkStatus();
+}
+
 void PosixEngineListenerImpl::AsyncConnectionAcceptor::Shutdown() {
   // The ShutdownHandle whould trigger any waiting notify_on_accept_ to get
   // scheduled with the not-OK status.

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.h

@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -33,7 +33,9 @@
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/slice_buffer.h>
 
+#include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -52,7 +54,7 @@ class PosixEngineListenerImpl
     : public std::enable_shared_from_this<PosixEngineListenerImpl> {
  public:
   PosixEngineListenerImpl(
-      EventEngine::Listener::AcceptCallback on_accept,
+      PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
       absl::AnyInvocable<void(absl::Status)> on_shutdown,
       const grpc_event_engine::experimental::EndpointConfig& config,
       std::unique_ptr<grpc_event_engine::experimental::MemoryAllocatorFactory>
@@ -60,12 +62,17 @@ class PosixEngineListenerImpl
       PosixEventPoller* poller, std::shared_ptr<EventEngine> engine);
   // Binds an address to the listener. This creates a ListenerSocket
   // and sets its fields appropriately.
-  absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr);
+  absl::StatusOr<int> Bind(
+      const EventEngine::ResolvedAddress& addr,
+      PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_bind_new_fd);
   // Signals event manager to listen for connections on all created sockets.
   absl::Status Start();
   // Trigger graceful shutdown of all asynchronous accept operations.
   void TriggerShutdown();
 
+  absl::Status HandleExternalConnection(int listener_fd, int fd,
+                                        SliceBuffer* pending_data);
+
   ~PosixEngineListenerImpl();
 
  private:
@@ -119,9 +126,18 @@ class PosixEngineListenerImpl
    public:
     explicit ListenerAsyncAcceptors(PosixEngineListenerImpl* listener)
         : listener_(listener){};
+
+    void UpdateOnAppendCallback(
+        PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_append) {
+      on_append_ = std::move(on_append);
+    }
+
     void Append(ListenerSocket socket) override {
       acceptors_.push_back(new AsyncConnectionAcceptor(
           listener_->engine_, listener_->shared_from_this(), socket));
+      if (on_append_) {
+        on_append_(socket.sock.Fd());
+      }
     }
 
     absl::StatusOr<ListenerSocket> Find(
@@ -148,6 +164,7 @@ class PosixEngineListenerImpl
     }
 
    private:
+    PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_append_;
     std::list<AsyncConnectionAcceptor*> acceptors_;
     PosixEngineListenerImpl* listener_;
   };
@@ -163,7 +180,7 @@ class PosixEngineListenerImpl
   // operation.
   ListenerAsyncAcceptors acceptors_ ABSL_GUARDED_BY(mu_);
   // Callback to be invoked upon accepting a connection.
-  EventEngine::Listener::AcceptCallback on_accept_;
+  PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept_;
   // Callback to be invoked upon shutdown of listener.
   absl::AnyInvocable<void(absl::Status)> on_shutdown_;
   // Set to true when the listener has started listening for new connections.
@@ -175,12 +192,10 @@ class PosixEngineListenerImpl
       memory_allocator_factory_;
 };
 
-class PosixEngineListener
-    : public grpc_event_engine::experimental::EventEngine::Listener {
+class PosixEngineListener : public PosixListenerWithFdSupport {
  public:
   PosixEngineListener(
-      grpc_event_engine::experimental::EventEngine::Listener::AcceptCallback
-          on_accept,
+      PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
       absl::AnyInvocable<void(absl::Status)> on_shutdown,
       const grpc_event_engine::experimental::EndpointConfig& config,
       std::unique_ptr<grpc_event_engine::experimental::MemoryAllocatorFactory>
@@ -189,24 +204,41 @@ class PosixEngineListener
       : impl_(std::make_shared<PosixEngineListenerImpl>(
             std::move(on_accept), std::move(on_shutdown), config,
             std::move(memory_allocator_factory), poller, std::move(engine))) {}
-  ~PosixEngineListener() override { impl_->TriggerShutdown(); };
+  ~PosixEngineListener() override { ShutdownListeningFds(); };
   absl::StatusOr<int> Bind(
       const grpc_event_engine::experimental::EventEngine::ResolvedAddress& addr)
       override {
-    return impl_->Bind(addr);
+    return impl_->Bind(addr, nullptr);
+  }
+  absl::StatusOr<int> BindWithFd(
+      const EventEngine::ResolvedAddress& addr,
+      PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_bind_new_fd)
+      override {
+    return impl_->Bind(addr, std::move(on_bind_new_fd));
+  }
+  absl::Status HandleExternalConnection(int listener_fd, int fd,
+                                        SliceBuffer* pending_data) override {
+    return impl_->HandleExternalConnection(listener_fd, fd, pending_data);
   }
   absl::Status Start() override { return impl_->Start(); }
 
+  void ShutdownListeningFds() override {
+    if (!shutdown_.exchange(true, std::memory_order_acq_rel)) {
+      impl_->TriggerShutdown();
+    }
+  }
+
  private:
   std::shared_ptr<PosixEngineListenerImpl> impl_;
+  // Set to true when the listener had been explicitly shutdown.
+  std::atomic<bool> shutdown_{false};
 };
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
 #include "src/core/lib/gprpp/crash.h"
 
-class PosixEngineListener
-    : public grpc_event_engine::experimental::EventEngine::Listener {
+class PosixEngineListener : public PosixListenerWithFdSupport {
  public:
   PosixEngineListener() = default;
   ~PosixEngineListener() override = default;
@@ -219,10 +251,29 @@ class PosixEngineListener
     grpc_core::Crash(
         "EventEngine::Listener::Start not supported on this platform");
   }
+  absl::StatusOr<int> BindWithFd(
+      const EventEngine::ResolvedAddress& /*addr*/,
+      PosixListenerWithFdSupport::OnPosixBindNewFdCallback
+      /*on_bind_new_fd*/) override {
+    grpc_core::Crash(
+        "PosixEngineListener::BindWithFd not supported on this "
+        "platform");
+  }
+  absl::Status HandleExternalConnection(
+      int /*listener_fd*/, int /*fd*/, SliceBuffer* /*pending_data*/) override {
+    grpc_core::Crash(
+        "PosixEngineListener::HandleExternalConnection not "
+        "supported on this platform");
+  }
+  void ShutdownListeningFds() override {
+    grpc_core::Crash(
+        "PosixEngineListener::ShutdownListeningFds not supported on "
+        "this platform");
+  }
 };
 
 #endif
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.cc

@@ -137,7 +137,6 @@ int GetMaxAcceptQueueSize() {
 absl::Status PrepareSocket(const PosixTcpOptions& options,
                            ListenerSocket& socket) {
   ResolvedAddress sockname_temp;
-  absl::Status error;
   int fd = socket.sock.Fd();
   GPR_ASSERT(fd >= 0);
   bool close_fd = true;

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.h

@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,10 +25,10 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-// This interface exists to allow different Event Engines to implement different
+// This interface exists to allow different EventEngines to implement different
 // custom interception operations while a socket is Appended. The
 // listener util functions are defined over this interface and thus can be
-// shared across multiple event engines.
+// shared across multiple EventEngines.
 class ListenerSocketsContainer {
  public:
   struct ListenerSocket {
@@ -55,7 +55,7 @@ class ListenerSocketsContainer {
   virtual ~ListenerSocketsContainer() = default;
 };
 
-// Creates and configures a socket to be used by the Event Engine Listener. The
+// Creates and configures a socket to be used by the EventEngine Listener. The
 // type of the socket to create is determined by the by the passed address. The
 // socket configuration is specified by passed tcp options. If successful, it
 // returns a ListenerSocketsContainer::ListenerSocket type which holds the
@@ -88,4 +88,4 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -313,4 +313,4 @@ struct PosixSocketWrapper::PosixSocketCreateResult {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H

data/src/core/lib/event_engine/posix_engine/timer.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -191,4 +191,4 @@ class TimerList {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H

data/src/core/lib/event_engine/posix_engine/timer_heap.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H
 
 #include <grpc/support/port_platform.h>
 
@@ -53,4 +53,4 @@ class TimerHeap {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H

data/src/core/lib/event_engine/posix_engine/timer_manager.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -111,4 +111,4 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
 
 #include <grpc/support/port_platform.h>
 
@@ -182,4 +182,4 @@ void TcpSetWriteTimestampsCallback(
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H

data/src/core/lib/event_engine/posix_engine/wakeup_fd_eventfd.h

@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H
 
 #include <grpc/support/port_platform.h>
 
@@ -42,4 +42,4 @@ class EventFdWakeupFd : public WakeupFd {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H

data/src/core/lib/event_engine/posix_engine/wakeup_fd_pipe.h

@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -42,4 +42,4 @@ class PipeWakeupFd : public WakeupFd {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H

data/src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h

@@ -39,8 +39,8 @@
 // 2. If the polling thread was awakened by a WakeupFd event, call
 //    WakeupFd::Consume() on it.
 //
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
 
 #include <grpc/support/port_platform.h>
 
@@ -73,4 +73,4 @@ class WakeupFd {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H

data/src/core/lib/event_engine/posix_engine/wakeup_fd_posix_default.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
 #include <grpc/support/port_platform.h>
 
 #include <memory>
@@ -34,4 +34,4 @@ absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd();
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H

data/src/core/lib/event_engine/resolved_address.cc

@@ -14,11 +14,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/resolved_address.h"
+
 #include <string.h>
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+
 // IWYU pragma: no_include <sys/socket.h>
 
 namespace grpc_event_engine {
@@ -37,5 +41,20 @@ const struct sockaddr* EventEngine::ResolvedAddress::address() const {
 
 socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
 
+EventEngine::ResolvedAddress CreateResolvedAddress(
+    const grpc_resolved_address& addr) {
+  return EventEngine::ResolvedAddress(
+      reinterpret_cast<const sockaddr*>(addr.addr), addr.len);
+}
+
+grpc_resolved_address CreateGRPCResolvedAddress(
+    const EventEngine::ResolvedAddress& ra) {
+  grpc_resolved_address grpc_addr;
+  memset(&grpc_addr, 0, sizeof(grpc_resolved_address));
+  memcpy(grpc_addr.addr, ra.address(), ra.size());
+  grpc_addr.len = ra.size();
+  return grpc_addr;
+}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/resolved_address_internal.h

@@ -0,0 +1,34 @@
+// Copyright 2022 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_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/resolved_address.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::ResolvedAddress CreateResolvedAddress(
+    const grpc_resolved_address& addr);
+
+grpc_resolved_address CreateGRPCResolvedAddress(
+    const EventEngine::ResolvedAddress& ra);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H

data/src/core/lib/event_engine/shim.cc

@@ -0,0 +1,56 @@
+// Copyright 2022 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/event_engine/shim.h"
+
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/iomgr/port.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+bool UseEventEngineClient() {
+// TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
+// available for other platforms.
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+  return grpc_core::IsEventEngineClientEnabled();
+#elif defined(GPR_WINDOWS)
+  return grpc_core::IsEventEngineClientEnabled();
+#else
+  return false;
+#endif
+}
+
+bool UseEventEngineListener() {
+// TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
+// available for other platforms.
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+  return grpc_core::IsEventEngineListenerEnabled();
+#else
+  return false;
+#endif
+}
+
+bool EventEngineSupportsFd() {
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+  return true;
+#else
+  return false;
+#endif
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/shim.h

@@ -0,0 +1,33 @@
+// Copyright 2022 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_EVENT_ENGINE_SHIM_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_SHIM_H
+
+// Platform-specific configuration for use of the EventEngine shims.
+
+#include <grpc/support/port_platform.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+bool UseEventEngineClient();
+
+bool UseEventEngineListener();
+
+bool EventEngineSupportsFd();
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_SHIM_H