refactor: share the native op envelope, decode, socket accessors, and io_uring service plumbing

Deduplicate the backend-independent parts of the native backends without
sharing the scheduler loop:

  - coro_op: the shared non-template op envelope (reactor_op_base, io_uring_op,
    overlapped_op derive from it) + coro_op_complete (drain/resume tail and
    decode_io_result); each backend keeps its own native-error -> error_code
    conversion.
  - native_socket_base: socket accessors shared by reactor and io_uring sockets.
  - io_uring_socket_service_base / io_uring_file_service_base: shared io_uring
    service construct/destroy/shutdown/close plumbing.

The scheduler loop is deliberately not shared — io_uring keeps its leader/follower loop, the reactors share reactor_scheduler, IOCP stays
standalone.

Author: mvandeberg

include/boost/corosio/native/detail/coro_op.hpp

@@ -0,0 +1,134 @@
+//
+// Copyright (c) 2026 Michael Vandeberg
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/corosio
+//
+
+#ifndef BOOST_COROSIO_NATIVE_DETAIL_CORO_OP_HPP
+#define BOOST_COROSIO_NATIVE_DETAIL_CORO_OP_HPP
+
+#include <boost/corosio/detail/config.hpp>
+#include <boost/corosio/detail/continuation_op.hpp>
+#include <boost/corosio/detail/scheduler_op.hpp>
+#include <boost/capy/ex/executor_ref.hpp>
+
+#include <atomic>
+#include <coroutine>
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <stop_token>
+#include <system_error>
+
+/*
+    Shared, non-template op envelope for every native backend — the readiness
+    reactors (epoll/kqueue/select), io_uring, and IOCP. It captures the part of
+    an async operation that is identical regardless of how completion is
+    reported: the coroutine to resume, the executor it dispatches on, the
+    output pointers, the stop_token wiring, the cancelled flag, and the
+    keepalive that holds the owning impl alive while the op is in flight.
+
+    What is deliberately NOT here (it differs by backend and stays in the
+    derived op layer):
+      - the result model: the reactors re-run the syscall and record
+        `errn`/`bytes_transferred` (reactor_op_base); io_uring stores the raw
+        `res`/`cqe_flags`; IOCP stores `dwError`/`bytes_transferred`. Each
+        decodes its own result.
+      - the submission + the kernel cancel action. Cancellation is unified only
+        at the call site via the virtual `on_cancel()` hook: the stop_callback
+        always targets `coro_op`, and each backend overrides `on_cancel()` —
+        the reactors route to the owning impl's cancel(), io_uring submits an
+        ASYNC_CANCEL SQE, IOCP calls the stored cancel_func_/CancelIoEx.
+
+    See tasks/proactor-dedup-decisions.md and coro-op-unification-scope.md.
+*/
+
+namespace boost::corosio::detail {
+
+/** Non-template op envelope shared by every native backend's operations.
+
+    `reactor_op_base`, `io_uring_op`, and `overlapped_op` all derive from this.
+    Derives from scheduler_op so ops queue intrusively and dispatch through the
+    function-pointer (io_uring/IOCP) or virtual (reactors) completion path —
+    hence both a default and a func_type constructor.
+
+    @note For IOCP, the concrete op multiply-inherits `OVERLAPPED` as its
+    first base (so `static_cast<OVERLAPPED*>` round-trips); `coro_op`
+    follows it.
+*/
+struct coro_op : scheduler_op
+{
+    /** Stop-callback handler: routes a stop_token firing to `on_cancel()`.
+
+        A single canceller type for both backends keeps `stop_cb` (and thus
+        `start()`) in this shared base; the backend-specific action lives
+        behind the `on_cancel()` virtual.
+    */
+    struct canceller
+    {
+        coro_op* op;
+        void operator()() const noexcept { op->on_cancel(); }
+    };
+
+    std::coroutine_handle<>  h;
+    detail::continuation_op  cont_op;
+    capy::executor_ref       ex;
+    std::error_code*         ec_out    = nullptr;
+    std::size_t*             bytes_out = nullptr;
+
+    /// True for receive/read ops (drives the zero-byte == EOF decision).
+    bool                     is_read      = false;
+    /// True when the submitted buffer was zero-length (suppresses EOF).
+    bool                     empty_buffer = false;
+
+    std::atomic<bool>                            cancelled{false};
+    std::optional<std::stop_callback<canceller>> stop_cb;
+
+    /// Keeps the owning impl alive while the op is in flight (the kernel
+    /// owns user buffers until completion). Dropped in the handler's resume
+    /// tail (see coro_op_complete.hpp).
+    std::shared_ptr<void>    impl_ptr;
+
+    /// Default-construct for virtual-dispatch backends (the reactors, which
+    /// override operator()/destroy() and leave func_ null).
+    coro_op() noexcept = default;
+
+    /// Construct with the completion function for func-pointer dispatch
+    /// (io_uring / IOCP completion handlers).
+    explicit coro_op(func_type func) noexcept : scheduler_op(func) {}
+
+    /** Arm the stop-token callback. Call before the op is submitted.
+
+        Resets the cancellation flag and (re)arms `stop_cb` against @a token.
+        Derived ops that carry extra pre-submit state (e.g. io_uring's
+        `sqe_set`) extend this.
+    */
+    void start(std::stop_token const& token)
+    {
+        cancelled.store(false, std::memory_order_relaxed);
+        stop_cb.reset();
+        if (token.stop_possible())
+            stop_cb.emplace(token, canceller{this});
+    }
+
+    /// Mark this op cancellation-requested. Shared by every backend.
+    void request_cancel() noexcept
+    {
+        cancelled.store(true, std::memory_order_release);
+    }
+
+    /** Backend cancellation hook, invoked when the stop_token fires.
+
+        The default just records the request. Backends override to also
+        drive the kernel: io_uring submits an ASYNC_CANCEL SQE; IOCP calls
+        its stored cancel_func_ (CancelIoEx / wait-reactor deregister).
+    */
+    virtual void on_cancel() noexcept { request_cancel(); }
+};
+
+} // namespace boost::corosio::detail
+
+#endif

include/boost/corosio/native/detail/coro_op_complete.hpp

@@ -0,0 +1,136 @@
+//
+// Copyright (c) 2026 Michael Vandeberg
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/corosio
+//
+
+#ifndef BOOST_COROSIO_NATIVE_DETAIL_CORO_OP_COMPLETE_HPP
+#define BOOST_COROSIO_NATIVE_DETAIL_CORO_OP_COMPLETE_HPP
+
+#include <boost/corosio/detail/dispatch_coro.hpp>
+#include <boost/corosio/native/detail/coro_op.hpp>
+#include <boost/capy/error.hpp>
+
+#include <cstddef>
+#include <memory>
+#include <system_error>
+
+/*
+    Shared completion-tail helpers for proactor ops. Every IOCP and io_uring
+    I/O handler ends the same way once its backend-specific result has been
+    decoded into ec_out/bytes_out:
+
+      1. disarm the stop_callback,
+      2. on the shutdown-drain path (owner == nullptr) just break the
+         impl_ptr keepalive cycle and return without resuming,
+      3. otherwise resume the coroutine on its executor, dropping the
+         keepalive only after the continuation has been handed off.
+
+    The *decode* step (raw DWORD/res -> {ec, bytes, eof, canceled}) stays
+    backend-specific because the raw encodings differ; in Phase 3 it is
+    formalized as `Traits::decode_result`. These two helpers capture the
+    backend-agnostic prologue and resume tail so the per-op handlers shrink to
+    "drain-or-decode, then resume".
+*/
+
+namespace boost::corosio::detail {
+
+/** Translate a decoded I/O result into `*ec_out` using the cancelled /
+    error / EOF / success priority shared by every native backend.
+
+    The raw error encodings differ per backend (reactor positive `errno`,
+    io_uring negative `res`, IOCP `DWORD`), so the native-error -> error_code
+    step stays backend-local: the caller passes @a err already converted
+    (an empty error_code means "no error"). This helper owns only the
+    priority logic, which is byte-for-byte identical everywhere:
+
+        cancelled                          -> operation_canceled
+        err set                            -> err
+        is_read && bytes == 0 && !empty    -> end_of_file
+        otherwise                          -> success
+
+    Writes nothing when @a ec_out is null. Does not touch bytes_out — callers
+    that report a byte count write it separately (connect/wait carry none).
+
+    @param ec_out        Destination (may be null).
+    @param cancelled     The op's cancellation flag.
+    @param err           Backend error already converted to error_code, or a
+                         default-constructed error_code on success.
+    @param is_read       True only for reads that should map a 0-byte
+                         completion to EOF — false for writes, connect, wait,
+                         and datagrams (a 0-byte datagram is success, not EOF).
+    @param bytes         Bytes transferred (consulted only for the EOF test).
+    @param empty_buffer  True when the submitted buffer was zero-length,
+                         which suppresses the otherwise-spurious EOF.
+*/
+inline void
+decode_io_result(
+    std::error_code* ec_out,
+    bool             cancelled,
+    std::error_code  err,
+    bool             is_read,
+    std::size_t      bytes,
+    bool             empty_buffer) noexcept
+{
+    if (!ec_out)
+        return;
+    if (cancelled)
+        *ec_out = capy::error::canceled;
+    else if (err)
+        *ec_out = err;
+    else if (is_read && bytes == 0 && !empty_buffer)
+        *ec_out = capy::error::eof;
+    else
+        *ec_out = {};
+}
+
+/** Completion prologue shared by every proactor handler.
+
+    Disarms the stop_callback, then detects the shutdown-drain path.
+
+    @param owner The scheduler pointer (nullptr during shutdown drain).
+    @param self  The completing op.
+    @return True if this was a shutdown drain — the caller must `return`
+            immediately without decoding or resuming. On that path the
+            impl_ptr keepalive is dropped here (which may destroy the impl,
+            and with it the op storage).
+*/
+inline bool
+coro_drain_if_shutdown(void* owner, coro_op* self) noexcept
+{
+    self->stop_cb.reset();
+    if (owner == nullptr)
+    {
+        auto suicide = std::move(self->impl_ptr);
+        return true;
+    }
+    return false;
+}
+
+/** Resume tail shared by every proactor handler.
+
+    Resumes the op's coroutine on its executor and then drops the impl_ptr
+    keepalive. The keepalive is moved into a local that is released *after*
+    `resume()` returns, matching the existing io_uring ordering: the impl (and
+    therefore this op's storage) may be destroyed as the local goes out of
+    scope, so nothing may touch `*self` after the resume.
+
+    @pre `self->ec_out`/`bytes_out` have already been written by the
+         backend's decode step.
+*/
+inline void
+coro_resume(coro_op* self) noexcept
+{
+    self->cont_op.cont.h = self->h;
+    auto next = dispatch_coro(self->ex, self->cont_op.cont);
+    auto suicide = std::move(self->impl_ptr);
+    next.resume();
+    // suicide drops here; may destroy impl + self.
+}
+
+} // namespace boost::corosio::detail
+
+#endif

include/boost/corosio/native/detail/io_uring/io_uring_dgram_ops.hpp

@@ -18,6 +18,7 @@
 
 #include <boost/corosio/detail/dispatch_coro.hpp>
 #include <boost/corosio/native/detail/io_uring/io_uring_op.hpp>
+#include <boost/corosio/native/detail/coro_op_complete.hpp>
 #include <boost/corosio/native/detail/speculative_state.hpp>
 #include <boost/corosio/native/detail/io_uring/io_uring_socket_ops.hpp>
 #include <boost/corosio/native/detail/make_err.hpp>
@@ -132,23 +133,18 @@ struct uring_dgram_send_op : io_uring_op
         std::uint32_t /*bytes*/, std::uint32_t /*error*/) noexcept
     {
         auto* self = static_cast<uring_dgram_send_op*>(base);
-        self->stop_cb.reset();
-
-        if (owner == nullptr)
-        {
-            auto suicide = std::move(self->impl_ptr);
+        if (coro_drain_if_shutdown(owner, self))
             return;
-        }
 
-        if (self->ec_out)
-        {
-            if (self->cancelled.load(std::memory_order_acquire))
-                *self->ec_out = capy::error::canceled;
-            else if (self->res < 0)
-                *self->ec_out = make_err(-self->res);
-            else
-                *self->ec_out = {};
-        }
+        if (self->sched_)
+            self->sched_->reset_inline_budget();
+
+        // Datagram send: no EOF (a 0-byte send is success).
+        decode_io_result(
+            self->ec_out,
+            self->cancelled.load(std::memory_order_acquire),
+            self->res < 0 ? make_err(-self->res) : std::error_code{},
+            /*is_read=*/false, /*bytes=*/0, /*empty_buffer=*/false);
         if (self->bytes_out)
             *self->bytes_out = (self->res >= 0)
                 ? static_cast<std::size_t>(self->res) : 0;
@@ -159,10 +155,7 @@ struct uring_dgram_send_op : io_uring_op
             self->spec_state->on_async_write_ready();
         }
 
-        self->cont_op.cont.h = self->h;
-        auto next = dispatch_coro(self->ex, self->cont_op.cont);
-        auto suicide = std::move(self->impl_ptr);
-        next.resume();
+        coro_resume(self);
     }
 };
 
@@ -299,23 +292,19 @@ struct uring_dgram_recv_op : io_uring_op
         std::uint32_t /*bytes*/, std::uint32_t /*error*/) noexcept
     {
         auto* self = static_cast<uring_dgram_recv_op*>(base);
-        self->stop_cb.reset();
-
-        if (owner == nullptr)
-        {
-            auto suicide = std::move(self->impl_ptr);
+        if (coro_drain_if_shutdown(owner, self))
             return;
-        }
 
-        if (self->ec_out)
-        {
-            if (self->cancelled.load(std::memory_order_acquire))
-                *self->ec_out = capy::error::canceled;
-            else if (self->res < 0)
-                *self->ec_out = make_err(-self->res);
-            else
-                *self->ec_out = {};   // zero-byte datagram is success, not EOF
-        }
+        if (self->sched_)
+            self->sched_->reset_inline_budget();
+
+        // Datagram recv: a 0-byte datagram is success, not EOF — is_read
+        // stays false so the shared decode never maps it to end_of_file.
+        decode_io_result(
+            self->ec_out,
+            self->cancelled.load(std::memory_order_acquire),
+            self->res < 0 ? make_err(-self->res) : std::error_code{},
+            /*is_read=*/false, /*bytes=*/0, /*empty_buffer=*/false);
         if (self->bytes_out)
             *self->bytes_out = (self->res >= 0)
                 ? static_cast<std::size_t>(self->res) : 0;
@@ -332,10 +321,7 @@ struct uring_dgram_recv_op : io_uring_op
             self->source_writer(self->source_writer_ctx,
                 self->source_storage, self->source_len);
 
-        self->cont_op.cont.h = self->h;
-        auto next = dispatch_coro(self->ex, self->cont_op.cont);
-        auto suicide = std::move(self->impl_ptr);
-        next.resume();
+        coro_resume(self);
     }
 };