fix: four production bugs surfaced by the coverage push

- socket_option: IP_MULTICAST_LOOP and IP_MULTICAST_TTL are u_char options
  on BSD-derived kernels; the previous int storage caused setsockopt to
  return EINVAL on macOS. Add byte_boolean_option / byte_integer_option
  (public ABI) and byte_boolean<> / byte_integer<> (native templates)
  with single-byte storage; rebase multicast_loop_v4 and multicast_hops_v4
  onto them. IPv6 variants are unaffected.

- native_local_datagram_socket: include of the deleted IOCP datagram
  service was reachable in any IOCP build. Wrap the whole header in
  BOOST_COROSIO_POSIX to mirror local_datagram_socket.hpp.

- posix_resolver_service and win_resolver_service: replace
  make_service<thread_pool>() with use_service<thread_pool>(). The
  original call threw 'invalid argument' whenever
  io_context_options.thread_pool_size != 1 because pre_create_services
  had already constructed the pool with non-default args.

- iocp wait_reactor and tcp_acceptor_service: resolve a pre-cancelled
  stop_token race in wait() and accept() paths that caused tests to
  hang on Windows IOCP under specific completion orderings.

Author: sgerbino

include/boost/corosio/native/detail/iocp/win_resolver_service.hpp

@@ -495,7 +495,7 @@ win_resolver::do_reverse_resolve_work(pool_work_item* w) noexcept
 inline win_resolver_service::win_resolver_service(
     capy::execution_context& ctx, scheduler& sched)
     : sched_(sched)
-    , pool_(ctx.make_service<thread_pool>())
+    , pool_(ctx.use_service<thread_pool>())
 {
 }
 

include/boost/corosio/native/detail/iocp/win_tcp_acceptor_service.hpp

@@ -1373,6 +1373,14 @@ win_tcp_acceptor_internal::accept(
     }
 
     svc_.on_pending(&op);
+
+    // If the stop_token was already cancelled when start() was called,
+    // the CancelIoEx in the canceller fired before AcceptEx was
+    // submitted and had no effect.  Re-issue now that the I/O is
+    // pending so the completion posts with ERROR_OPERATION_ABORTED.
+    if (op.cancelled.load(std::memory_order_acquire))
+        ::CancelIoEx(reinterpret_cast<HANDLE>(socket_), &op);
+
     return std::noop_coroutine();
 }
 

include/boost/corosio/native/detail/iocp/win_wait_reactor.hpp

@@ -248,6 +248,16 @@ inline void
 win_wait_reactor::register_wait(
     SOCKET fd, wait_type w, overlapped_op* op)
 {
+    // If the op was already cancelled (e.g. pre-cancelled stop_token
+    // fired synchronously before this call), complete immediately
+    // instead of registering.  Otherwise the reactor would park the
+    // op forever because the earlier cancel_wait() found nothing to
+    // cancel in registered_.
+    if (op->cancelled.load(std::memory_order_acquire))
+    {
+        sched_.on_completion(op, 0, 0);
+        return;
+    }
     {
         std::lock_guard lock(mutex_);
         pending_register_.push_back(entry{fd, w, op});

include/boost/corosio/native/detail/posix/posix_resolver_service.hpp

@@ -36,7 +36,7 @@ class BOOST_COROSIO_DECL posix_resolver_service final
 
     posix_resolver_service(capy::execution_context& ctx, scheduler& sched)
         : sched_(&sched)
-        , pool_(ctx.make_service<thread_pool>())
+        , pool_(ctx.use_service<thread_pool>())
     {
     }
 

include/boost/corosio/native/native_local_datagram_socket.hpp

@@ -10,6 +10,10 @@
 #ifndef BOOST_COROSIO_NATIVE_NATIVE_LOCAL_DATAGRAM_SOCKET_HPP
 #define BOOST_COROSIO_NATIVE_NATIVE_LOCAL_DATAGRAM_SOCKET_HPP
 
+#include <boost/corosio/detail/platform.hpp>
+
+#if BOOST_COROSIO_POSIX
+
 #include <boost/corosio/local_datagram_socket.hpp>
 #include <boost/corosio/backend.hpp>
 
@@ -25,10 +29,6 @@
 #if BOOST_COROSIO_HAS_KQUEUE
 #include <boost/corosio/native/detail/kqueue/kqueue_types.hpp>
 #endif
-
-#if BOOST_COROSIO_HAS_IOCP
-#include <boost/corosio/native/detail/iocp/win_local_dgram_service.hpp>
-#endif
 #endif // !BOOST_COROSIO_MRDOCS
 
 namespace boost::corosio {
@@ -486,4 +486,6 @@ class native_local_datagram_socket : public local_datagram_socket
 
 } // namespace boost::corosio
 
+#endif // BOOST_COROSIO_POSIX
+
 #endif // BOOST_COROSIO_NATIVE_NATIVE_LOCAL_DATAGRAM_SOCKET_HPP

include/boost/corosio/native/native_socket_option.hpp

@@ -248,6 +248,86 @@ class integer
     }
 };
 
+/** A boolean socket option with single-byte storage.
+
+    Some BSD-derived kernels (macOS, FreeBSD) require certain IPv4 multicast
+    options (`IP_MULTICAST_LOOP`) to be set with a one-byte value and return
+    `EINVAL` for the four-byte form that Linux accepts. This template
+    provides `unsigned char` storage so the option works on every platform.
+
+    @tparam Level The protocol level.
+    @tparam Name The option name.
+*/
+template<int Level, int Name>
+class byte_boolean
+{
+    unsigned char value_ = 0;
+
+public:
+    byte_boolean() = default;
+
+    explicit byte_boolean(bool v) noexcept : value_(v ? 1 : 0) {}
+
+    byte_boolean& operator=(bool v) noexcept
+    {
+        value_ = v ? 1 : 0;
+        return *this;
+    }
+
+    bool value() const noexcept { return value_ != 0; }
+    explicit operator bool() const noexcept { return value_ != 0; }
+    bool operator!() const noexcept { return value_ == 0; }
+
+    static constexpr int level() noexcept { return Level; }
+    static constexpr int name() noexcept { return Name; }
+
+    void* data() noexcept { return &value_; }
+    void const* data() const noexcept { return &value_; }
+    std::size_t size() const noexcept { return sizeof(value_); }
+
+    void resize(std::size_t) noexcept {}
+};
+
+/** An integer socket option with single-byte storage.
+
+    Same rationale as `byte_boolean`: BSD-derived kernels require
+    `IP_MULTICAST_TTL` to be set with a one-byte value. Linux accepts
+    one byte too, so single-byte storage is portable. Values are
+    truncated to the 0–255 range.
+
+    @tparam Level The protocol level.
+    @tparam Name The option name.
+*/
+template<int Level, int Name>
+class byte_integer
+{
+    unsigned char value_ = 0;
+
+public:
+    byte_integer() = default;
+
+    explicit byte_integer(int v) noexcept
+        : value_(static_cast<unsigned char>(v))
+    {}
+
+    byte_integer& operator=(int v) noexcept
+    {
+        value_ = static_cast<unsigned char>(v);
+        return *this;
+    }
+
+    int value() const noexcept { return value_; }
+
+    static constexpr int level() noexcept { return Level; }
+    static constexpr int name() noexcept { return Name; }
+
+    void* data() noexcept { return &value_; }
+    void const* data() const noexcept { return &value_; }
+    std::size_t size() const noexcept { return sizeof(value_); }
+
+    void resize(std::size_t) noexcept {}
+};
+
 /** The SO_LINGER socket option (native variant).
 
     Controls behavior when closing a socket with unsent data.
@@ -375,13 +455,13 @@ using reuse_port = boolean<SOL_SOCKET, SO_REUSEPORT>;
 #endif
 
 /// Enable loopback of outgoing multicast on IPv4 (IP_MULTICAST_LOOP).
-using multicast_loop_v4 = boolean<IPPROTO_IP, IP_MULTICAST_LOOP>;
+using multicast_loop_v4 = byte_boolean<IPPROTO_IP, IP_MULTICAST_LOOP>;
 
 /// Enable loopback of outgoing multicast on IPv6 (IPV6_MULTICAST_LOOP).
 using multicast_loop_v6 = boolean<IPPROTO_IPV6, IPV6_MULTICAST_LOOP>;
 
 /// Set the multicast TTL for IPv4 (IP_MULTICAST_TTL).
-using multicast_hops_v4 = integer<IPPROTO_IP, IP_MULTICAST_TTL>;
+using multicast_hops_v4 = byte_integer<IPPROTO_IP, IP_MULTICAST_TTL>;
 
 /// Set the multicast hop limit for IPv6 (IPV6_MULTICAST_HOPS).
 using multicast_hops_v6 = integer<IPPROTO_IPV6, IPV6_MULTICAST_HOPS>;

include/boost/corosio/socket_option.hpp

@@ -172,6 +172,131 @@ class integer_option
     }
 };
 
+/** Base class for concrete boolean socket options with single-byte storage.
+
+    Some BSD-derived kernels (macOS, FreeBSD) require certain IPv4 multicast
+    options (`IP_MULTICAST_LOOP`) to be set with a one-byte value and return
+    `EINVAL` for the four-byte form that Linux accepts. This base provides
+    `unsigned char` storage so the same options work on every platform.
+*/
+class byte_boolean_option
+{
+    unsigned char value_ = 0;
+
+public:
+    /// Construct with default value (disabled).
+    byte_boolean_option() = default;
+
+    /** Construct with an explicit value.
+
+        @param v `true` to enable the option, `false` to disable.
+    */
+    explicit byte_boolean_option(bool v) noexcept : value_(v ? 1 : 0) {}
+
+    /// Assign a new value.
+    byte_boolean_option& operator=(bool v) noexcept
+    {
+        value_ = v ? 1 : 0;
+        return *this;
+    }
+
+    /// Return the option value.
+    bool value() const noexcept
+    {
+        return value_ != 0;
+    }
+
+    /// Return the option value.
+    explicit operator bool() const noexcept
+    {
+        return value_ != 0;
+    }
+
+    /// Return the negated option value.
+    bool operator!() const noexcept
+    {
+        return value_ == 0;
+    }
+
+    /// Return a pointer to the underlying storage.
+    void* data() noexcept
+    {
+        return &value_;
+    }
+
+    /// Return a pointer to the underlying storage.
+    void const* data() const noexcept
+    {
+        return &value_;
+    }
+
+    /// Return the size of the underlying storage.
+    std::size_t size() const noexcept
+    {
+        return sizeof(value_);
+    }
+
+    /// Storage is already one byte; no normalization needed.
+    void resize(std::size_t) noexcept {}
+};
+
+/** Base class for concrete integer socket options with single-byte storage.
+
+    Same rationale as `byte_boolean_option`: BSD-derived kernels require
+    `IP_MULTICAST_TTL` to be set with a one-byte value. Linux accepts
+    one-byte too, so single-byte storage is portable.
+*/
+class byte_integer_option
+{
+    unsigned char value_ = 0;
+
+public:
+    /// Construct with default value (zero).
+    byte_integer_option() = default;
+
+    /** Construct with an explicit value.
+
+        @param v The option value; truncated to one byte.
+    */
+    explicit byte_integer_option(int v) noexcept
+        : value_(static_cast<unsigned char>(v))
+    {}
+
+    /// Assign a new value; truncated to one byte.
+    byte_integer_option& operator=(int v) noexcept
+    {
+        value_ = static_cast<unsigned char>(v);
+        return *this;
+    }
+
+    /// Return the option value.
+    int value() const noexcept
+    {
+        return value_;
+    }
+
+    /// Return a pointer to the underlying storage.
+    void* data() noexcept
+    {
+        return &value_;
+    }
+
+    /// Return a pointer to the underlying storage.
+    void const* data() const noexcept
+    {
+        return &value_;
+    }
+
+    /// Return the size of the underlying storage.
+    std::size_t size() const noexcept
+    {
+        return sizeof(value_);
+    }
+
+    /// Storage is already one byte; no normalization needed.
+    void resize(std::size_t) noexcept {}
+};
+
 /** Disable Nagle's algorithm (TCP_NODELAY).
 
     @par Example
@@ -430,16 +555,19 @@ class BOOST_COROSIO_DECL linger
 
 /** Enable loopback of outgoing multicast on IPv4 (IP_MULTICAST_LOOP).
 
+    Uses single-byte storage because BSD-derived kernels (macOS, FreeBSD)
+    reject the four-byte form with `EINVAL`. Linux accepts either size.
+
     @par Example
     @code
     sock.set_option( socket_option::multicast_loop_v4( true ) );
     @endcode
 */
-class BOOST_COROSIO_DECL multicast_loop_v4 : public boolean_option
+class BOOST_COROSIO_DECL multicast_loop_v4 : public byte_boolean_option
 {
 public:
-    using boolean_option::boolean_option;
-    using boolean_option::operator=;
+    using byte_boolean_option::byte_boolean_option;
+    using byte_boolean_option::operator=;
 
     /// Return the protocol level.
     static int level() noexcept;
@@ -470,16 +598,20 @@ class BOOST_COROSIO_DECL multicast_loop_v6 : public boolean_option
 
 /** Set the multicast TTL for IPv4 (IP_MULTICAST_TTL).
 
+    Uses single-byte storage because BSD-derived kernels (macOS, FreeBSD)
+    reject the four-byte form with `EINVAL`. Linux accepts either size.
+    Values are truncated to the 0–255 range.
+
     @par Example
     @code
     sock.set_option( socket_option::multicast_hops_v4( 4 ) );
     @endcode
 */
-class BOOST_COROSIO_DECL multicast_hops_v4 : public integer_option
+class BOOST_COROSIO_DECL multicast_hops_v4 : public byte_integer_option
 {
 public:
-    using integer_option::integer_option;
-    using integer_option::operator=;
+    using byte_integer_option::byte_integer_option;
+    using byte_integer_option::operator=;
 
     /// Return the protocol level.
     static int level() noexcept;