Diff coverage report for

//

//

// Copyright (c) 2026 Steve Gerbino

// Copyright (c) 2026 Steve Gerbino

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// 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)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/cppalliance/corosio

// Official repository: https://github.com/cppalliance/corosio

//

//

#ifndef BOOST_COROSIO_UDP_SOCKET_HPP

#ifndef BOOST_COROSIO_UDP_SOCKET_HPP

#define BOOST_COROSIO_UDP_SOCKET_HPP

#define BOOST_COROSIO_UDP_SOCKET_HPP

#include <boost/corosio/detail/config.hpp>

#include <boost/corosio/detail/config.hpp>

#include <boost/corosio/detail/platform.hpp>

#include <boost/corosio/detail/platform.hpp>

#include <boost/corosio/detail/except.hpp>

#include <boost/corosio/detail/except.hpp>

#include <boost/corosio/detail/native_handle.hpp>

#include <boost/corosio/detail/native_handle.hpp>

#include <boost/corosio/detail/op_base.hpp>

#include <boost/corosio/detail/op_base.hpp>

#include <boost/corosio/io/io_object.hpp>

#include <boost/corosio/io/io_object.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/corosio/detail/buffer_param.hpp>

#include <boost/corosio/detail/buffer_param.hpp>

#include <boost/corosio/endpoint.hpp>

#include <boost/corosio/endpoint.hpp>

#include <boost/corosio/message_flags.hpp>

#include <boost/corosio/message_flags.hpp>

#include <boost/corosio/udp.hpp>

#include <boost/corosio/udp.hpp>

#include <boost/capy/ex/executor_ref.hpp>

#include <boost/capy/ex/executor_ref.hpp>

#include <boost/capy/ex/execution_context.hpp>

#include <boost/capy/ex/execution_context.hpp>

#include <boost/capy/ex/io_env.hpp>

#include <boost/capy/ex/io_env.hpp>

#include <boost/capy/concept/executor.hpp>

#include <boost/capy/concept/executor.hpp>

#include <system_error>

#include <system_error>

#include <concepts>

#include <concepts>

#include <coroutine>

#include <coroutine>

#include <cstddef>

#include <cstddef>

#include <stop_token>

#include <stop_token>

#include <type_traits>

#include <type_traits>

namespace boost::corosio {

namespace boost::corosio {

/** An asynchronous UDP socket for coroutine I/O.

/** An asynchronous UDP socket for coroutine I/O.

    This class provides asynchronous UDP datagram operations that

    This class provides asynchronous UDP datagram operations that

    return awaitable types. Each operation participates in the affine

    return awaitable types. Each operation participates in the affine

    awaitable protocol, ensuring coroutines resume on the correct

    awaitable protocol, ensuring coroutines resume on the correct

    executor.

    executor.

    Supports two modes of operation:

    Supports two modes of operation:

    **Connectionless mode**: each `send_to` specifies a destination

    **Connectionless mode**: each `send_to` specifies a destination

    endpoint, and each `recv_from` captures the source endpoint.

    endpoint, and each `recv_from` captures the source endpoint.

    The socket must be opened (and optionally bound) before I/O.

    The socket must be opened (and optionally bound) before I/O.

    **Connected mode**: call `connect()` to set a default peer,

    **Connected mode**: call `connect()` to set a default peer,

    then use `send()`/`recv()` without endpoint arguments.

    then use `send()`/`recv()` without endpoint arguments.

    The kernel filters incoming datagrams to those from the

    The kernel filters incoming datagrams to those from the

    connected peer.

    connected peer.

    @par Thread Safety

    @par Thread Safety

    Distinct objects: Safe.@n

    Distinct objects: Safe.@n

    Shared objects: Unsafe. A socket must not have concurrent

    Shared objects: Unsafe. A socket must not have concurrent

    operations of the same type (e.g., two simultaneous recv_from).

    operations of the same type (e.g., two simultaneous recv_from).

    One send_to and one recv_from may be in flight simultaneously.

    One send_to and one recv_from may be in flight simultaneously.

    @par Example

    @par Example

    @code

    @code

    // Connectionless mode

    // Connectionless mode

    io_context ioc;

    io_context ioc;

    udp_socket sock( ioc );

    udp_socket sock( ioc );

    sock.open( udp::v4() );

    sock.open( udp::v4() );

    sock.bind( endpoint( ipv4_address::any(), 9000 ) );

    sock.bind( endpoint( ipv4_address::any(), 9000 ) );

    char buf[1024];

    char buf[1024];

    endpoint sender;

    endpoint sender;

    auto [ec, n] = co_await sock.recv_from(

    auto [ec, n] = co_await sock.recv_from(

        capy::mutable_buffer( buf, sizeof( buf ) ), sender );

        capy::mutable_buffer( buf, sizeof( buf ) ), sender );

    if ( !ec )

    if ( !ec )

        co_await sock.send_to(

        co_await sock.send_to(

            capy::const_buffer( buf, n ), sender );

            capy::const_buffer( buf, n ), sender );

    // Connected mode

    // Connected mode

    udp_socket csock( ioc );

    udp_socket csock( ioc );

    auto [cec] = co_await csock.connect(

    auto [cec] = co_await csock.connect(

        endpoint( ipv4_address::loopback(), 9000 ) );

        endpoint( ipv4_address::loopback(), 9000 ) );

    if ( !cec )

    if ( !cec )

        co_await csock.send(

        co_await csock.send(

            capy::const_buffer( buf, n ) );

            capy::const_buffer( buf, n ) );

    @endcode

    @endcode

*/

*/

class BOOST_COROSIO_DECL udp_socket : public io_object

class BOOST_COROSIO_DECL udp_socket : public io_object

{

{

public:

public:

    /** Define backend hooks for UDP socket operations.

    /** Define backend hooks for UDP socket operations.

        Platform backends (epoll, kqueue, select) derive from

        Platform backends (epoll, kqueue, select) derive from

        this to implement datagram I/O and option management.

        this to implement datagram I/O and option management.

    */

    */

    struct implementation : io_object::implementation

    struct implementation : io_object::implementation

    {

    {

        /** Initiate an asynchronous send_to operation.

        /** Initiate an asynchronous send_to operation.

            @param h Coroutine handle to resume on completion.

            @param h Coroutine handle to resume on completion.

            @param ex Executor for dispatching the completion.

            @param ex Executor for dispatching the completion.

            @param buf The buffer data to send.

            @param buf The buffer data to send.

            @param dest The destination endpoint.

            @param dest The destination endpoint.

            @param flags Platform message flags (e.g. `MSG_DONTWAIT`).

            @param flags Platform message flags (e.g. `MSG_DONTWAIT`).

            @param token Stop token for cancellation.

            @param token Stop token for cancellation.

            @param ec Output error code.

            @param ec Output error code.

            @param bytes_out Output bytes transferred.

            @param bytes_out Output bytes transferred.

            @return Coroutine handle to resume immediately.

            @return Coroutine handle to resume immediately.

        */

        */

        virtual std::coroutine_handle<> send_to(

        virtual std::coroutine_handle<> send_to(

            std::coroutine_handle<> h,

            std::coroutine_handle<> h,

            capy::executor_ref ex,

            capy::executor_ref ex,

            buffer_param buf,

            buffer_param buf,

            endpoint dest,

            endpoint dest,

            int flags,

            int flags,

            std::stop_token token,

            std::stop_token token,

            std::error_code* ec,

            std::error_code* ec,

            std::size_t* bytes_out) = 0;

            std::size_t* bytes_out) = 0;

        /** Initiate an asynchronous recv_from operation.

        /** Initiate an asynchronous recv_from operation.

            @param h Coroutine handle to resume on completion.

            @param h Coroutine handle to resume on completion.

            @param ex Executor for dispatching the completion.

            @param ex Executor for dispatching the completion.

            @param buf The buffer to receive into.

            @param buf The buffer to receive into.

            @param source Output endpoint for the sender's address.

            @param source Output endpoint for the sender's address.

            @param flags Platform message flags (e.g. `MSG_PEEK`).

            @param flags Platform message flags (e.g. `MSG_PEEK`).

            @param token Stop token for cancellation.

            @param token Stop token for cancellation.

            @param ec Output error code.

            @param ec Output error code.

            @param bytes_out Output bytes transferred.

            @param bytes_out Output bytes transferred.

            @return Coroutine handle to resume immediately.

            @return Coroutine handle to resume immediately.

        */

        */

        virtual std::coroutine_handle<> recv_from(

        virtual std::coroutine_handle<> recv_from(

            std::coroutine_handle<> h,

            std::coroutine_handle<> h,

            capy::executor_ref ex,

            capy::executor_ref ex,

            buffer_param buf,

            buffer_param buf,

            endpoint* source,

            endpoint* source,

            int flags,

            int flags,

            std::stop_token token,

            std::stop_token token,

            std::error_code* ec,

            std::error_code* ec,

            std::size_t* bytes_out) = 0;

            std::size_t* bytes_out) = 0;

        /// Return the platform socket descriptor.

        /// Return the platform socket descriptor.

        virtual native_handle_type native_handle() const noexcept = 0;

        virtual native_handle_type native_handle() const noexcept = 0;

        /** Request cancellation of pending asynchronous operations.

        /** Request cancellation of pending asynchronous operations.

            All outstanding operations complete with operation_canceled

            All outstanding operations complete with operation_canceled

            error. Check `ec == cond::canceled` for portable comparison.

            error. Check `ec == cond::canceled` for portable comparison.

        */

        */

        virtual void cancel() noexcept = 0;

        virtual void cancel() noexcept = 0;

        /** Set a socket option.

        /** Set a socket option.

            @param level The protocol level (e.g. `SOL_SOCKET`).

            @param level The protocol level (e.g. `SOL_SOCKET`).

            @param optname The option name.

            @param optname The option name.

            @param data Pointer to the option value.

            @param data Pointer to the option value.

            @param size Size of the option value in bytes.

            @param size Size of the option value in bytes.

            @return Error code on failure, empty on success.

            @return Error code on failure, empty on success.

        */

        */

        virtual std::error_code set_option(

        virtual std::error_code set_option(

            int level,

            int level,

            int optname,

            int optname,

            void const* data,

            void const* data,

            std::size_t size) noexcept = 0;

            std::size_t size) noexcept = 0;

        /** Get a socket option.

        /** Get a socket option.

            @param level The protocol level (e.g. `SOL_SOCKET`).

            @param level The protocol level (e.g. `SOL_SOCKET`).

            @param optname The option name.

            @param optname The option name.

            @param data Pointer to receive the option value.

            @param data Pointer to receive the option value.

            @param size On entry, the size of the buffer. On exit,

            @param size On entry, the size of the buffer. On exit,

                the size of the option value.

                the size of the option value.

            @return Error code on failure, empty on success.

            @return Error code on failure, empty on success.

        */

        */

        virtual std::error_code

        virtual std::error_code

        get_option(int level, int optname, void* data, std::size_t* size)

        get_option(int level, int optname, void* data, std::size_t* size)

            const noexcept = 0;

            const noexcept = 0;

        /// Return the cached local endpoint.

        /// Return the cached local endpoint.

        virtual endpoint local_endpoint() const noexcept = 0;

        virtual endpoint local_endpoint() const noexcept = 0;

        /// Return the cached remote endpoint (connected mode).

        /// Return the cached remote endpoint (connected mode).

        virtual endpoint remote_endpoint() const noexcept = 0;

        virtual endpoint remote_endpoint() const noexcept = 0;

        /** Initiate an asynchronous connect to set the default peer.

        /** Initiate an asynchronous connect to set the default peer.

            @param h Coroutine handle to resume on completion.

            @param h Coroutine handle to resume on completion.

            @param ex Executor for dispatching the completion.

            @param ex Executor for dispatching the completion.

            @param ep The remote endpoint to connect to.

            @param ep The remote endpoint to connect to.

            @param token Stop token for cancellation.

            @param token Stop token for cancellation.

            @param ec Output error code.

            @param ec Output error code.

            @return Coroutine handle to resume immediately.

            @return Coroutine handle to resume immediately.

        */

        */

        virtual std::coroutine_handle<> connect(

        virtual std::coroutine_handle<> connect(

            std::coroutine_handle<> h,

            std::coroutine_handle<> h,

            capy::executor_ref ex,

            capy::executor_ref ex,

            endpoint ep,

            endpoint ep,

            std::stop_token token,

            std::stop_token token,

            std::error_code* ec) = 0;

            std::error_code* ec) = 0;

        /** Initiate an asynchronous connected send operation.

        /** Initiate an asynchronous connected send operation.

            @param h Coroutine handle to resume on completion.

            @param h Coroutine handle to resume on completion.

            @param ex Executor for dispatching the completion.

            @param ex Executor for dispatching the completion.

            @param buf The buffer data to send.

            @param buf The buffer data to send.

            @param flags Platform message flags (e.g. `MSG_DONTWAIT`).

            @param flags Platform message flags (e.g. `MSG_DONTWAIT`).

            @param token Stop token for cancellation.

            @param token Stop token for cancellation.

            @param ec Output error code.

            @param ec Output error code.

            @param bytes_out Output bytes transferred.

            @param bytes_out Output bytes transferred.

            @return Coroutine handle to resume immediately.

            @return Coroutine handle to resume immediately.

        */

        */

        virtual std::coroutine_handle<> send(

        virtual std::coroutine_handle<> send(

            std::coroutine_handle<> h,

            std::coroutine_handle<> h,

            capy::executor_ref ex,

            capy::executor_ref ex,

            buffer_param buf,

            buffer_param buf,

            int flags,

            int flags,

            std::stop_token token,

            std::stop_token token,

            std::error_code* ec,

            std::error_code* ec,

            std::size_t* bytes_out) = 0;

            std::size_t* bytes_out) = 0;

        /** Initiate an asynchronous connected recv operation.

        /** Initiate an asynchronous connected recv operation.

            @param h Coroutine handle to resume on completion.

            @param h Coroutine handle to resume on completion.

            @param ex Executor for dispatching the completion.

            @param ex Executor for dispatching the completion.

            @param buf The buffer to receive into.

            @param buf The buffer to receive into.

            @param flags Platform message flags (e.g. `MSG_PEEK`).

            @param flags Platform message flags (e.g. `MSG_PEEK`).

            @param token Stop token for cancellation.

            @param token Stop token for cancellation.

            @param ec Output error code.

            @param ec Output error code.

            @param bytes_out Output bytes transferred.

            @param bytes_out Output bytes transferred.

            @return Coroutine handle to resume immediately.

            @return Coroutine handle to resume immediately.

        */

        */

        virtual std::coroutine_handle<> recv(

        virtual std::coroutine_handle<> recv(

            std::coroutine_handle<> h,

            std::coroutine_handle<> h,

            capy::executor_ref ex,

            capy::executor_ref ex,

            buffer_param buf,

            buffer_param buf,

            int flags,

            int flags,

            std::stop_token token,

            std::stop_token token,

            std::error_code* ec,

            std::error_code* ec,

            std::size_t* bytes_out) = 0;

            std::size_t* bytes_out) = 0;

    };

    };

    /** Represent the awaitable returned by @ref send_to.

    /** Represent the awaitable returned by @ref send_to.

        Captures the destination endpoint and buffer, then dispatches

        Captures the destination endpoint and buffer, then dispatches

        to the backend implementation on suspension.

        to the backend implementation on suspension.

    */

    */

    struct send_to_awaitable

    struct send_to_awaitable

        : detail::bytes_op_base<send_to_awaitable>

        : detail::bytes_op_base<send_to_awaitable>

    {

    {

        udp_socket& s_;

        udp_socket& s_;

        buffer_param buf_;

        buffer_param buf_;

        endpoint dest_;

        endpoint dest_;

        int flags_;

        int flags_;

            udp_socket& s, buffer_param buf,

            udp_socket& s, buffer_param buf,

            endpoint dest, int flags = 0) noexcept

            endpoint dest, int flags = 0) noexcept

            std::coroutine_handle<> h, capy::executor_ref ex) const

            std::coroutine_handle<> h, capy::executor_ref ex) const

        {

        {

        }

        }

    };

    };

    /** Represent the awaitable returned by @ref recv_from.

    /** Represent the awaitable returned by @ref recv_from.

        Captures the source endpoint reference and buffer, then

        Captures the source endpoint reference and buffer, then

        dispatches to the backend implementation on suspension.

        dispatches to the backend implementation on suspension.

    */

    */

    struct recv_from_awaitable

    struct recv_from_awaitable

        : detail::bytes_op_base<recv_from_awaitable>

        : detail::bytes_op_base<recv_from_awaitable>

    {

    {

        udp_socket& s_;

        udp_socket& s_;

        buffer_param buf_;

        buffer_param buf_;

        endpoint& source_;

        endpoint& source_;

        int flags_;

        int flags_;

            udp_socket& s, buffer_param buf,

            udp_socket& s, buffer_param buf,

            endpoint& source, int flags = 0) noexcept

            endpoint& source, int flags = 0) noexcept

            std::coroutine_handle<> h, capy::executor_ref ex) const

            std::coroutine_handle<> h, capy::executor_ref ex) const

        {

        {

        }

        }

    };

    };

    /// Represent the awaitable returned by @ref connect.

    /// Represent the awaitable returned by @ref connect.

    struct connect_awaitable

    struct connect_awaitable

        : detail::void_op_base<connect_awaitable>

        : detail::void_op_base<connect_awaitable>

    {

    {

        udp_socket& s_;

        udp_socket& s_;

        endpoint endpoint_;

        endpoint endpoint_;

            std::coroutine_handle<> h, capy::executor_ref ex) const

            std::coroutine_handle<> h, capy::executor_ref ex) const

        {

        {

        }

        }

    };

    };

    /// Represent the awaitable returned by @ref send.

    /// Represent the awaitable returned by @ref send.

    struct send_awaitable

    struct send_awaitable

        : detail::bytes_op_base<send_awaitable>

        : detail::bytes_op_base<send_awaitable>

    {

    {

        udp_socket& s_;

        udp_socket& s_;

        buffer_param buf_;

        buffer_param buf_;

        int flags_;

        int flags_;

            udp_socket& s, buffer_param buf,

            udp_socket& s, buffer_param buf,

            int flags = 0) noexcept

            int flags = 0) noexcept

            std::coroutine_handle<> h, capy::executor_ref ex) const

            std::coroutine_handle<> h, capy::executor_ref ex) const

        {

        {

        }

        }

    };

    };

    /// Represent the awaitable returned by @ref recv.

    /// Represent the awaitable returned by @ref recv.

    struct recv_awaitable

    struct recv_awaitable

        : detail::bytes_op_base<recv_awaitable>

        : detail::bytes_op_base<recv_awaitable>

    {

    {

        udp_socket& s_;

        udp_socket& s_;

        buffer_param buf_;

        buffer_param buf_;

        int flags_;

        int flags_;

            udp_socket& s, buffer_param buf,

            udp_socket& s, buffer_param buf,

            int flags = 0) noexcept

            int flags = 0) noexcept

            std::coroutine_handle<> h, capy::executor_ref ex) const

            std::coroutine_handle<> h, capy::executor_ref ex) const

        {

        {

        }

        }

    };

    };

public:

public:

    /** Destructor.

    /** Destructor.

        Closes the socket if open, cancelling any pending operations.

        Closes the socket if open, cancelling any pending operations.

    */

    */

    ~udp_socket() override;

    ~udp_socket() override;

    /** Construct a socket from an execution context.

    /** Construct a socket from an execution context.

        @param ctx The execution context that will own this socket.

        @param ctx The execution context that will own this socket.

    */

    */

    explicit udp_socket(capy::execution_context& ctx);

    explicit udp_socket(capy::execution_context& ctx);

    /** Construct a socket from an executor.

    /** Construct a socket from an executor.

        The socket is associated with the executor's context.

        The socket is associated with the executor's context.

        @param ex The executor whose context will own the socket.

        @param ex The executor whose context will own the socket.

    */

    */

    template<class Ex>

    template<class Ex>

        requires(!std::same_as<std::remove_cvref_t<Ex>, udp_socket>) &&

        requires(!std::same_as<std::remove_cvref_t<Ex>, udp_socket>) &&

        capy::Executor<Ex>

        capy::Executor<Ex>

    explicit udp_socket(Ex const& ex) : udp_socket(ex.context())

    explicit udp_socket(Ex const& ex) : udp_socket(ex.context())

    {

    {

    }

    }

    /** Move constructor.

    /** Move constructor.

        Transfers ownership of the socket resources.

        Transfers ownership of the socket resources.

        @param other The socket to move from.

        @param other The socket to move from.

    */

    */

    /** Move assignment operator.

    /** Move assignment operator.

        Closes any existing socket and transfers ownership.

        Closes any existing socket and transfers ownership.

        @param other The socket to move from.

        @param other The socket to move from.

        @return Reference to this socket.

        @return Reference to this socket.

    */

    */

    {

    {

        {

        {

        }

        }

    }

    }

    udp_socket(udp_socket const&)            = delete;

    udp_socket(udp_socket const&)            = delete;

    udp_socket& operator=(udp_socket const&) = delete;

    udp_socket& operator=(udp_socket const&) = delete;

    /** Open the socket.

    /** Open the socket.

        Creates a UDP socket and associates it with the platform

        Creates a UDP socket and associates it with the platform

        reactor.

        reactor.

        @param proto The protocol (IPv4 or IPv6). Defaults to

        @param proto The protocol (IPv4 or IPv6). Defaults to

            `udp::v4()`.

            `udp::v4()`.

        @throws std::system_error on failure.

        @throws std::system_error on failure.

    */

    */

    void open(udp proto = udp::v4());

    void open(udp proto = udp::v4());

    /** Close the socket.

    /** Close the socket.

        Releases socket resources. Any pending operations complete

        Releases socket resources. Any pending operations complete

        with `errc::operation_canceled`.

        with `errc::operation_canceled`.

    */

    */

    void close();

    void close();

    /** Check if the socket is open.

    /** Check if the socket is open.

        @return `true` if the socket is open and ready for operations.

        @return `true` if the socket is open and ready for operations.

    */

    */

    {

    {

#if BOOST_COROSIO_HAS_IOCP && !defined(BOOST_COROSIO_MRDOCS)

#if BOOST_COROSIO_HAS_IOCP && !defined(BOOST_COROSIO_MRDOCS)

        return h_ && get().native_handle() != ~native_handle_type(0);

        return h_ && get().native_handle() != ~native_handle_type(0);

#else

#else

#endif

#endif

    }

    }

    /** Bind the socket to a local endpoint.

    /** Bind the socket to a local endpoint.

        Associates the socket with a local address and port.

        Associates the socket with a local address and port.

        Required before calling `recv_from`.

        Required before calling `recv_from`.

        @param ep The local endpoint to bind to.

        @param ep The local endpoint to bind to.

        @return Error code on failure, empty on success.

        @return Error code on failure, empty on success.

        @throws std::logic_error if the socket is not open.

        @throws std::logic_error if the socket is not open.

    */

    */

    [[nodiscard]] std::error_code bind(endpoint ep);

    [[nodiscard]] std::error_code bind(endpoint ep);

    /** Cancel any pending asynchronous operations.

    /** Cancel any pending asynchronous operations.

        All outstanding operations complete with

        All outstanding operations complete with

        `errc::operation_canceled`. Check `ec == cond::canceled`

        `errc::operation_canceled`. Check `ec == cond::canceled`

        for portable comparison.

        for portable comparison.

    */

    */

    void cancel();

    void cancel();

    /** Get the native socket handle.

    /** Get the native socket handle.

        @return The native socket handle, or -1 if not open.

        @return The native socket handle, or -1 if not open.

    */

    */

    native_handle_type native_handle() const noexcept;

    native_handle_type native_handle() const noexcept;

    /** Set a socket option.

    /** Set a socket option.

        @param opt The option to set.

        @param opt The option to set.

        @throws std::logic_error if the socket is not open.

        @throws std::logic_error if the socket is not open.

        @throws std::system_error on failure.

        @throws std::system_error on failure.

    */

    */

    template<class Option>

    template<class Option>

    {

    {

            Option::level(), Option::name(), opt.data(), opt.size());

            Option::level(), Option::name(), opt.data(), opt.size());

    /** Get a socket option.

    /** Get a socket option.

        @return The current option value.

        @return The current option value.

        @throws std::logic_error if the socket is not open.

        @throws std::logic_error if the socket is not open.

        @throws std::system_error on failure.

        @throws std::system_error on failure.

    */

    */

    template<class Option>

    template<class Option>

    {

    {

        std::error_code ec =

        std::error_code ec =

    }

    }

    /** Get the local endpoint of the socket.

    /** Get the local endpoint of the socket.

        @return The local endpoint, or a default endpoint if not bound.

        @return The local endpoint, or a default endpoint if not bound.

    */

    */

    endpoint local_endpoint() const noexcept;

    endpoint local_endpoint() const noexcept;

    /** Send a datagram to the specified destination.

    /** Send a datagram to the specified destination.

        @param buf The buffer containing data to send.

        @param buf The buffer containing data to send.

        @param dest The destination endpoint.

        @param dest The destination endpoint.

        @param flags Message flags (e.g. message_flags::dont_route).

        @param flags Message flags (e.g. message_flags::dont_route).

        @return An awaitable that completes with

        @return An awaitable that completes with

            `io_result<std::size_t>`.

            `io_result<std::size_t>`.

        @throws std::logic_error if the socket is not open.

        @throws std::logic_error if the socket is not open.

    */

    */

    template<capy::ConstBufferSequence Buffers>

    template<capy::ConstBufferSequence Buffers>

        Buffers const& buf,

        Buffers const& buf,

        endpoint dest,

        endpoint dest,

        corosio::message_flags flags)

        corosio::message_flags flags)

    {

    {