<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/experimental/socket</h2><form method='post'><textarea name='content' class='file-edit'>// &lt;experimental/socket&gt; -*- C++ -*-

// Copyright (C) 2015-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file experimental/socket
 *  This is a TS C++ Library header.
 *  @ingroup networking-ts
 */

#ifndef _GLIBCXX_EXPERIMENTAL_SOCKET
#define _GLIBCXX_EXPERIMENTAL_SOCKET

#pragma GCC system_header

#if __cplusplus &gt;= 201402L

#include &lt;experimental/netfwd&gt;
#include &lt;experimental/buffer&gt;
#include &lt;experimental/io_context&gt;
#include &lt;experimental/bits/net.h&gt;
#include &lt;streambuf&gt;
#include &lt;istream&gt;
#include &lt;bits/unique_ptr.h&gt;
#if _GLIBCXX_HAVE_UNISTD_H
# include &lt;unistd.h&gt;
# ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
#  include &lt;sys/socket.h&gt;	// socket etc
# endif
# ifdef _GLIBCXX_HAVE_SYS_IOCTL_H
#  include &lt;sys/ioctl.h&gt;	// ioctl
# endif
# ifdef _GLIBCXX_HAVE_SYS_UIO_H
#  include &lt;sys/uio.h&gt;		// iovec
# endif
# ifdef _GLIBCXX_HAVE_POLL_H
#  include &lt;poll.h&gt;		// poll, pollfd, POLLIN, POLLOUT, POLLERR
# endif
# ifdef _GLIBCXX_HAVE_FCNTL_H
#  include &lt;fcntl.h&gt;		// fcntl, F_GETFL, F_SETFL
# endif
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace experimental
{
namespace net
{
inline namespace v1
{

  /** @addtogroup networking-ts
   *  @{
   */

  enum class socket_errc {  // TODO decide values
    already_open = 3,
    not_found = 4
  };

} // namespace v1
} // namespace net
} // namespace experimental

  template&lt;&gt;
    struct is_error_code_enum&lt;experimental::net::v1::socket_errc&gt;
    : public true_type {};

namespace experimental
{
namespace net
{
inline namespace v1
{
  const error_category&amp; socket_category() noexcept
  {
    struct __cat : error_category
    {
      const char* name() const noexcept { return &quot;socket&quot;; }

      std::string message(int __e) const
      {
	if (__e == (int)socket_errc::already_open)
	  return &quot;already open&quot;;
	else if (__e == (int)socket_errc::not_found)
	  return &quot;endpoint not found&quot;;
	return &quot;socket error&quot;;
      }

      virtual void __message(int) { } // TODO dual ABI XXX
    };
    static __cat __c;
    return __c;
  }

  inline error_code
  make_error_code(socket_errc __e) noexcept
  { return error_code(static_cast&lt;int&gt;(__e), socket_category()); }

  inline error_condition
  make_error_condition(socket_errc __e) noexcept
  { return error_condition(static_cast&lt;int&gt;(__e), socket_category()); }


  // TODO GettableSocket reqs
  // TODO SettableSocket reqs
  // TODO BooleanSocketOption reqs
  // TODO IntegerSocketOption reqs
  // TODO IoControlCommand reqs
  // TODO ConnectCondition reqs

  /** @brief Sockets
   * @{
   */

  class socket_base
  {
  public:
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
    class broadcast : public __sockopt_crtp&lt;broadcast, bool&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;broadcast, bool&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_BROADCAST;
    };

    class debug : public __sockopt_crtp&lt;debug, bool&gt;
    {
    public:
      friend __sockopt_crtp&lt;debug, bool&gt;;
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_DEBUG;
    };

    class do_not_route : public __sockopt_crtp&lt;do_not_route, bool&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;do_not_route, bool&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_DONTROUTE;
    };

    class keep_alive : public __sockopt_crtp&lt;keep_alive, bool&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;keep_alive, bool&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_KEEPALIVE;
    };

    class linger : public __sockopt_crtp&lt;linger, ::linger&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

      linger() noexcept = default;

      linger(bool __e, chrono::seconds __t) noexcept
      {
	enabled(__e);
	timeout(__t);
      }

      bool
      enabled() const noexcept
      { return _M_value.l_onoff != 0; }

      void
      enabled(bool __e) noexcept
      { _M_value.l_onoff = int(__e); }

      chrono::seconds
      timeout() const noexcept
      { return chrono::seconds(_M_value.l_linger); }

      void
      timeout(chrono::seconds __t) noexcept
      { _M_value.l_linger = __t.count(); }

    private:
      friend __sockopt_crtp&lt;linger, ::linger&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_LINGER;
    };

    class out_of_band_inline : public __sockopt_crtp&lt;out_of_band_inline, bool&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;out_of_band_inline, bool&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_OOBINLINE;
    };

    class receive_buffer_size : public __sockopt_crtp&lt;receive_buffer_size&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;receive_buffer_size&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_RCVBUF;
    };

    class receive_low_watermark : public __sockopt_crtp&lt;receive_low_watermark&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;receive_low_watermark&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_RCVLOWAT;
    };

    class reuse_address : public __sockopt_crtp&lt;reuse_address, bool&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;reuse_address, bool&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_REUSEADDR;
    };

    class send_buffer_size : public __sockopt_crtp&lt;send_buffer_size&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;send_buffer_size&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_SNDBUF;
    };

    class send_low_watermark : public __sockopt_crtp&lt;send_low_watermark&gt;
    {
    public:
      using __sockopt_crtp::__sockopt_crtp;
      using __sockopt_crtp::operator=;

    private:
      friend __sockopt_crtp&lt;send_low_watermark&gt;;
      static const int _S_level = SOL_SOCKET;
      static const int _S_name = SO_SNDLOWAT;
    };
#endif // HAVE_SYS_SOCKET_H

    enum shutdown_type : int { };
#if defined SHUT_RD &amp;&amp; defined SHUT_WR &amp;&amp; defined SHUT_RDWR
    static constexpr shutdown_type shutdown_receive = (shutdown_type)SHUT_RD;
    static constexpr shutdown_type shutdown_send    = (shutdown_type)SHUT_WR;
    static constexpr shutdown_type shutdown_both    = (shutdown_type)SHUT_RDWR;
#endif

    enum wait_type : int { };
#ifdef _GLIBCXX_HAVE_POLL_H
    static constexpr wait_type wait_read  = (wait_type)POLLIN;
    static constexpr wait_type wait_write = (wait_type)POLLOUT;
    static constexpr wait_type wait_error = (wait_type)POLLERR;
#else
    static constexpr wait_type wait_read  = (wait_type)1;
    static constexpr wait_type wait_write = (wait_type)2;
    static constexpr wait_type wait_error = (wait_type)4;
#endif

    enum message_flags : int { };
#if defined MSG_PEEK &amp;&amp; defined MSG_OOB &amp;&amp; defined MSG_DONTROUTE
    static constexpr message_flags message_peek
      = (message_flags)MSG_PEEK;
    static constexpr message_flags message_out_of_band
      = (message_flags)MSG_OOB;
    static constexpr message_flags message_do_not_route
      = (message_flags)MSG_DONTROUTE;
#endif

#ifdef SOMAXCONN
    static constexpr int max_listen_connections = SOMAXCONN;
#else
    static constexpr int max_listen_connections = 4;
#endif

    // message_flags bitmask operations are defined as hidden friends.

    friend constexpr message_flags
    operator&amp;(message_flags __f1, message_flags __f2) noexcept
    { return message_flags( int(__f1) &amp; int(__f2) ); }

    friend constexpr message_flags
    operator|(message_flags __f1, message_flags __f2) noexcept
    { return message_flags( int(__f1) | int(__f2) ); }

    friend constexpr message_flags
    operator^(message_flags __f1, message_flags __f2) noexcept
    { return message_flags( int(__f1) ^ int(__f2) ); }

    friend constexpr message_flags
    operator~(message_flags __f) noexcept
    { return message_flags( ~int(__f) ); }

    friend constexpr message_flags&amp;
    operator&amp;=(message_flags&amp; __f1, message_flags __f2) noexcept
    { return __f1 = (__f1 &amp; __f2); }

    friend constexpr message_flags&amp;
    operator|=(message_flags&amp; __f1, message_flags __f2) noexcept
    { return __f1 = (__f1 | __f2); }

    friend constexpr message_flags&amp;
    operator^=(message_flags&amp; __f1, message_flags __f2) noexcept
    { return __f1 = (__f1 ^ __f2); }

#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
  protected:
    struct __msg_hdr : ::msghdr
    {
#ifdef IOV_MAX
      using __iovec_array = array&lt;::iovec, IOV_MAX&gt;;
#elif _GLIBCXX_HAVE_UNISTD_H
      struct __iovec_array
      {
	__iovec_array() : _M_ptr(new ::iovec[size()]) { }

	::iovec&amp; operator[](size_t __n) noexcept { return _M_ptr[__n]; }

	::iovec* data() noexcept { return _M_ptr.get(); }

	static size_t size()
	{
	  static const size_t __iov_max = ::sysconf(_SC_IOV_MAX);
	  return __iov_max;
	}

      private:
	unique_ptr&lt;::iovec[]&gt; _M_ptr;
      };
#else
      using __iovec_array = array&lt;::iovec, 16&gt;;
#endif

      __iovec_array _M_iov;

      template&lt;typename _BufferSequence&gt;
	explicit
	__msg_hdr(const _BufferSequence&amp; __buffers)
	: msghdr()
	{
	  auto __buf = net::buffer_sequence_begin(__buffers);
	  const auto __bufend = net::buffer_sequence_end(__buffers);
	  size_t __len = 0;
	  while (__buf != __bufend &amp;&amp; __len != _M_iov.size())
	    {
	      _M_iov[__len].iov_base = (void*)__buf-&gt;data();
	      _M_iov[__len].iov_len = __buf-&gt;size();
	      ++__buf;
	      ++__len;
	    }
	  this-&gt;msg_iovlen = __len;
	  this-&gt;msg_iov = _M_iov.data();
	}

      template&lt;typename _BufferSequence, typename _Endpoint&gt;
	__msg_hdr(const _BufferSequence&amp; __buffers, const _Endpoint&amp; __ep)
	: __msg_hdr(__buffers)
	{
	  this-&gt;msg_name = __ep.data();
	  this-&gt;msg_namelen = __ep.size();
	}
    };
#endif

  protected:
    socket_base() = default;
    ~socket_base() = default;
  };

  // TODO define socket_base static constants in .so for C++14 mode

#if _GLIBCXX_HAVE_UNISTD_H

  class __socket_impl
  {
  protected:

    using executor_type = io_context::executor_type;
    using native_handle_type = int;

    explicit
    __socket_impl(io_context&amp; __ctx) : _M_ctx(std::addressof(__ctx)) { }

    __socket_impl(__socket_impl&amp;&amp; __rhs)
    : _M_ctx(__rhs._M_ctx),
      _M_sockfd(std::exchange(__rhs._M_sockfd, -1)),
      _M_bits(std::exchange(__rhs._M_bits, {}))
    { }

    __socket_impl&amp;
    operator=(__socket_impl&amp;&amp; __rhs)
    {
      _M_ctx = __rhs._M_ctx;
      _M_sockfd = std::exchange(__rhs._M_sockfd, -1);
      _M_bits = std::exchange(__rhs._M_bits, {});
      return *this;
    }

    ~__socket_impl() = default;

    __socket_impl(const __socket_impl&amp;) = delete;
    __socket_impl&amp; operator=(const __socket_impl&amp;) = delete;

    executor_type get_executor() noexcept { return _M_ctx-&gt;get_executor(); }

    native_handle_type native_handle() noexcept { return _M_sockfd; }

    bool is_open() const noexcept { return _M_sockfd != -1; }

    void
    close(error_code&amp; __ec)
    {
      if (is_open())
	{
	  cancel(__ec);
	  if (!__ec)
	    {
	      if (::close(_M_sockfd) == -1)
		__ec.assign(errno, generic_category());
	      else
		{
		  get_executor().context()._M_remove_fd(_M_sockfd);
		  _M_sockfd = -1;
		}
	    }
	}
    }

    void cancel(error_code&amp; __ec) { _M_ctx-&gt;cancel(_M_sockfd, __ec); }

    void
    non_blocking(bool __mode, error_code&amp;)
    { _M_bits.non_blocking = __mode; }

    bool non_blocking() const { return _M_bits.non_blocking; }

    void
    native_non_blocking(bool __mode, error_code&amp; __ec)
    {
#if defined _GLIBCXX_HAVE_FCNTL_H &amp;&amp; defined _GLIBCXX_HAVE_DECL_O_NONBLOCK
      int __flags = ::fcntl(_M_sockfd, F_GETFL, 0);
      if (__flags &gt;= 0)
	{
	  if (__mode)
	    __flags |= O_NONBLOCK;
	  else
	    __flags &amp;= ~O_NONBLOCK;
	  __flags = ::fcntl(_M_sockfd, F_SETFL, __flags);
	}
      if (__flags == -1)
	__ec.assign(errno, generic_category());
      else
	{
	  __ec.clear();
	  _M_bits.native_non_blocking = __mode;
	}
#else
      __ec = std::make_error_code(std::errc::not_supported);
#endif
    }

    bool
    native_non_blocking() const
    {
#if defined _GLIBCXX_HAVE_FCNTL_H &amp;&amp; defined _GLIBCXX_HAVE_DECL_O_NONBLOCK
      if (_M_bits.native_non_blocking == -1)
	{
	  const int __flags = ::fcntl(_M_sockfd, F_GETFL, 0);
	  if (__flags == -1)
	    return 0;
	  _M_bits.native_non_blocking = __flags &amp; O_NONBLOCK;
	}
      return _M_bits.native_non_blocking;
#else
      return false;
#endif
    }

    io_context*	_M_ctx;
    int		_M_sockfd{-1};
    struct {
      unsigned		non_blocking : 1;
      mutable signed	native_non_blocking : 2;
      unsigned		enable_connection_aborted : 1;
    } _M_bits{};
  };

  template&lt;typename _Protocol&gt;
    class __basic_socket_impl : public __socket_impl
    {
      using __base = __socket_impl;

    protected:
      using protocol_type = _Protocol;
      using endpoint_type = typename protocol_type::endpoint;

      explicit
      __basic_socket_impl(io_context&amp; __ctx) : __base(__ctx) { }

      __basic_socket_impl(__basic_socket_impl&amp;&amp;) = default;

      template&lt;typename _OtherProtocol&gt;
	__basic_socket_impl(__basic_socket_impl&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	: __base(std::move(__rhs)), _M_protocol(std::move(__rhs._M_protocol))
	{ }

      __basic_socket_impl&amp;
      operator=(__basic_socket_impl&amp;&amp; __rhs)
      {
	if (this == std::addressof(__rhs))
	  return *this;
	_M_close();
	__base::operator=(std::move(__rhs));
	return *this;
      }

      ~__basic_socket_impl() { _M_close(); }

      __basic_socket_impl(const __basic_socket_impl&amp;) = delete;
      __basic_socket_impl&amp; operator=(const __basic_socket_impl&amp;) = delete;

      void
      open(const protocol_type&amp; __protocol, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	if (is_open())
	  __ec = socket_errc::already_open;
	else
	  {
	    _M_protocol = __protocol;
	    _M_sockfd = ::socket(__protocol.family(), __protocol.type(),
				 __protocol.protocol());
	    if (is_open())
	      {
		get_executor().context()._M_add_fd(_M_sockfd);
	      __ec.clear();
	      }
	    else
	      __ec.assign(errno, std::generic_category());
	  }
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
      }

      void
      assign(const protocol_type&amp; __protocol,
	     const native_handle_type&amp; __native_socket,
	     error_code&amp; __ec)
      {
	if (is_open())
	  __ec = socket_errc::already_open;
	else
	  {
	    _M_protocol = __protocol;
	    _M_bits.native_non_blocking = -1;
	    _M_sockfd = __native_socket;
	    if (is_open())
	      {
		get_executor().context()._M_add_fd(_M_sockfd);
		__ec.clear();
	      }
	    else
	      __ec.assign(errno, std::generic_category());
	  }
      }

      native_handle_type release(error_code&amp; __ec)
      {
	__glibcxx_assert(is_open());
	cancel(__ec);
	return std::exchange(_M_sockfd, -1);
      }

      template&lt;typename _SettableSocketOption&gt;
	void
	set_option(const _SettableSocketOption&amp; __option, error_code&amp; __ec)
	{
# ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  int __result = ::setsockopt(_M_sockfd, __option.level(_M_protocol),
				      __option.name(_M_protocol),
				      __option.data(_M_protocol),
				      __option.size(_M_protocol));
	  if (__result == -1)
	    __ec.assign(errno, generic_category());
	  else
	    __ec.clear();
#else
	  __ec = std::make_error_code(std::errc::not_supported);
#endif
	}

      template&lt;typename _GettableSocketOption&gt;
	void
	get_option(_GettableSocketOption&amp; __option, error_code&amp; __ec) const
	{
# ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  int __result = ::getsockopt(_M_sockfd, __option.level(_M_protocol),
				      __option.name(_M_protocol),
				      __option.data(_M_protocol),
				      __option.size(_M_protocol));
	  if (__result == -1)
	    __ec.assign(errno, generic_category());
	  else
	    __ec.clear();
#else
	  __ec = std::make_error_code(std::errc::not_supported);
#endif
	}

      template&lt;typename _IoControlCommand&gt;
	void
	io_control(_IoControlCommand&amp; __command, error_code&amp; __ec)
	{
#ifdef _GLIBCXX_HAVE_SYS_IOCTL_H
	  int __result = ::ioctl(_M_sockfd, __command.name(),
				 __command.data());
	  if (__result == -1)
	    __ec.assign(errno, generic_category());
	  else
	    __ec.clear();
#else
	  __ec = std::make_error_code(std::errc::not_supported);
#endif
	}

      endpoint_type
      local_endpoint(error_code&amp; __ec) const
      {
	endpoint_type __endpoint;
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	socklen_t __endpoint_len = __endpoint.capacity();
	if (::getsockname(_M_sockfd, (sockaddr*)__endpoint.data(),
			  &amp;__endpoint_len) == -1)
	  {
	    __ec.assign(errno, generic_category());
	    return endpoint_type{};
	  }
	__ec.clear();
	__endpoint.resize(__endpoint_len);
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
	return __endpoint;
      }

      void
      bind(const endpoint_type&amp; __endpoint, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	if (::bind(_M_sockfd, (sockaddr*)__endpoint.data(), __endpoint.size())
	    == -1)
	  __ec.assign(errno, generic_category());
	else
	  __ec.clear();
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
      }

      _Protocol	_M_protocol{ endpoint_type{}.protocol() };

    private:
      void
      _M_close()
      {
	if (is_open())
	  {
	    error_code __ec;
	    cancel(__ec);
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	    set_option(socket_base::linger{false, chrono::seconds{}}, __ec);
#endif
	    ::close(_M_sockfd);
	  }
      }
    };

  template&lt;typename _Protocol&gt;
    class basic_socket
    : public socket_base, private __basic_socket_impl&lt;_Protocol&gt;
    {
      using __base = __basic_socket_impl&lt;_Protocol&gt;;

    public:
      // types:

      using executor_type = io_context::executor_type;
      using native_handle_type = int;
      using protocol_type = _Protocol;
      using endpoint_type = typename protocol_type::endpoint;

      static_assert(__detail::__protocol&lt;protocol_type&gt;,
		    &quot;protocol_type meets the Protocol requirements&quot;);

      // basic_socket operations:

      executor_type get_executor() noexcept { return __base::get_executor(); }

      native_handle_type
      native_handle() noexcept { return __base::native_handle(); }

      void
      open(const protocol_type&amp; __protocol = protocol_type())
      { open(__protocol, __throw_on_error{&quot;basic_socket::open&quot;}); }

      void
      open(const protocol_type&amp; __protocol, error_code&amp; __ec)
      { __base::open(__protocol, __ec); }

      void
      assign(const protocol_type&amp; __protocol,
	     const native_handle_type&amp; __native_socket)
      {
	assign(__protocol, __native_socket,
	       __throw_on_error{&quot;basic_socket::assign&quot;});
      }

      void
      assign(const protocol_type&amp; __protocol,
	     const native_handle_type&amp; __native_socket,
	     error_code&amp; __ec)
      { __base::assign(__protocol, __native_socket, __ec); }

      native_handle_type release()
      { return release(__throw_on_error{&quot;basic_socket::release&quot;}); }

      native_handle_type release(error_code&amp; __ec)
      { return __base::release(__ec); }

      _GLIBCXX_NODISCARD bool
      is_open() const noexcept { return __base::is_open(); }

      void close() { close(__throw_on_error{&quot;basic_socket::close&quot;}); }

      void close(error_code&amp; __ec) { __base::close(__ec); }

      void cancel() { cancel(__throw_on_error{&quot;basic_socket::cancel&quot;}); }

      void cancel(error_code&amp; __ec) { __base::cancel(__ec); }

      template&lt;typename _SettableSocketOption&gt;
	void
	set_option(const _SettableSocketOption&amp; __option)
	{ set_option(__option, __throw_on_error{&quot;basic_socket::set_option&quot;}); }

      template&lt;typename _SettableSocketOption&gt;
	void
	set_option(const _SettableSocketOption&amp; __option, error_code&amp; __ec)
	{ __base::set_option(__option, __ec); }

      template&lt;typename _GettableSocketOption&gt;
	void
	get_option(_GettableSocketOption&amp; __option) const
	{ get_option(__option, __throw_on_error{&quot;basic_socket::get_option&quot;}); }

      template&lt;typename _GettableSocketOption&gt;
	void
	get_option(_GettableSocketOption&amp; __option, error_code&amp; __ec) const
	{ __base::get_option(__option, __ec); }

      template&lt;typename _IoControlCommand&gt;
	void
	io_control(_IoControlCommand&amp; __command)
	{
	  io_control(__command, __throw_on_error{&quot;basic_socket::io_control&quot;});
	}

      template&lt;typename _IoControlCommand&gt;
	void
	io_control(_IoControlCommand&amp; __command, error_code&amp; __ec)
	{ __base::io_control(__command, __ec); }

      void
      non_blocking(bool __mode)
      { non_blocking(__mode, __throw_on_error{&quot;basic_socket::non_blocking&quot;}); }

      void
      non_blocking(bool __mode, error_code&amp; __ec)
      { __base::non_blocking(__mode, __ec); }

      bool non_blocking() const { return __base::non_blocking(); }

      void
      native_non_blocking(bool __mode)
      {
	native_non_blocking(__mode, __throw_on_error{
	    &quot;basic_socket::native_non_blocking&quot;});
      }

      void
      native_non_blocking(bool __mode, error_code&amp; __ec)
      { __base::native_non_blocking(__mode, __ec); }

      bool
      native_non_blocking() const
      { return __base::native_non_blocking(); }

      bool at_mark() const
      { return at_mark(__throw_on_error{&quot;basic_socket::at_mark&quot;}); }

      bool
      at_mark(error_code&amp; __ec) const
      {
#ifdef _GLIBCXX_HAVE_SOCKATMARK
	const int __result = ::sockatmark(native_handle());
	if (__result == -1)
	  {
	    __ec.assign(errno, generic_category());
	    return false;
	  }
	__ec.clear();
	return (bool)__result;
#else
	__ec = std::make_error_code(errc::operation_not_supported);
	return false;
#endif
      }

      size_t
      available() const
      { return available(__throw_on_error{&quot;basic_socket::available&quot;}); }

      size_t
      available(error_code&amp; __ec) const
      {
	if (!is_open())
	  {
	    __ec = std::make_error_code(errc::bad_file_descriptor);
	    return 0;
	  }
#if defined _GLIBCXX_HAVE_SYS_IOCTL_H &amp;&amp; defined FIONREAD
	int __avail = 0;
	if (::ioctl(this-&gt;_M_sockfd, FIONREAD, &amp;__avail) == -1)
	  {
	    __ec.assign(errno, generic_category());
	    return 0;
	  }
	__ec.clear();
	return __avail;
#else
	return 0;
#endif
      }

      void
      bind(const endpoint_type&amp; __endpoint)
      { return bind(__endpoint, __throw_on_error{&quot;basic_socket::bind&quot;}); }

      void
      bind(const endpoint_type&amp; __endpoint, error_code&amp; __ec)
      { __base::bind(__endpoint, __ec); }

      void shutdown(shutdown_type __what)
      { return shutdown(__what, __throw_on_error{&quot;basic_socket::shutdown&quot;}); }

      void
      shutdown(shutdown_type __what, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	if (::shutdown(native_handle(), static_cast&lt;int&gt;(__what)) == -1)
	  __ec.assign(errno, generic_category());
	else
	  __ec.clear();
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
      }

      endpoint_type
      local_endpoint() const
      {
	return local_endpoint(
	    __throw_on_error{&quot;basic_socket::local_endpoint&quot;});
      }

      endpoint_type
      local_endpoint(error_code&amp; __ec) const
      { return __base::local_endpoint(__ec); }

      endpoint_type
      remote_endpoint() const
      {
	return remote_endpoint(
	    __throw_on_error{&quot;basic_socket::remote_endpoint&quot;});
      }

      endpoint_type
      remote_endpoint(error_code&amp; __ec) const
      {
	endpoint_type __endpoint;
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	socklen_t __endpoint_len = __endpoint.capacity();
	if (::getpeername(this-&gt;_M_sockfd, (sockaddr*)__endpoint.data(),
			  &amp;__endpoint_len)
	    == -1)
	  {
	    __ec.assign(errno, generic_category());
	    return endpoint_type{};
	  }
	__ec.clear();
	__endpoint.resize(__endpoint_len);
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
	return __endpoint;
      }

      void
      connect(const endpoint_type&amp; __endpoint)
      {
	return connect(__endpoint, __throw_on_error{&quot;basic_socket::connect&quot;});
      }

      void
      connect(const endpoint_type&amp; __endpoint, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	if (!is_open())
	  {
	    open(__endpoint.protocol(), __ec);
	    if (__ec)
	      return;
	  }
	if (::connect(native_handle(), (const sockaddr*)__endpoint.data(),
		      __endpoint.size()) == -1)
	  __ec.assign(errno, generic_category());
	else
	  __ec.clear();
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
      }

      template&lt;typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code)&gt;
	async_connect(const endpoint_type&amp; __endpoint,
		      _CompletionToken&amp;&amp; __token)
	{
	  async_completion&lt;_CompletionToken, void(error_code)&gt; __init{__token};

	  if (!is_open())
	    {
	      error_code __ec;
	      open(__endpoint.protocol(), __ec);
	      if (__ec)
		{
                  auto __ex = net::get_associated_executor(
                      __init.completion_handler, get_executor());
                  auto __a = get_associated_allocator(
                      __init.completion_handler, std::allocator&lt;void&gt;());
                  __ex.post(
                      [__h = std::move(__init.completion_handler), __ec]
                      () mutable
                      { __h(__ec); }, __a);
		  return __init.result.get();
		}
	    }

	  get_executor().context().async_wait( native_handle(),
	      (int) socket_base::wait_read,
	      [__h = std::move(__init.completion_handler),
               __ep = std::move(__endpoint),
               __fd = native_handle()]
               (error_code __ec) mutable {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  if (!__ec &amp;&amp; ::connect(__fd, (const sockaddr*)__ep.data(),
					 __ep.size()) == -1)
                    __ec.assign(errno, generic_category());
#else
		  __ec = std::make_error_code(errc::operation_not_supported);
#endif
		  __h(__ec);
	      });
	  return __init.result.get();
	}

      void
      wait(wait_type __w)
      { return wait(__w, __throw_on_error{&quot;basic_socket::wait&quot;}); }

      void
      wait(wait_type __w, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_POLL_H
	::pollfd __fd;
	__fd.fd = native_handle();
	__fd.events = static_cast&lt;int&gt;(__w);
	int __res = ::poll(&amp;__fd, 1, -1);
	if (__res == -1)
	  __ec.assign(errno, generic_category());
	else
	  __ec.clear();
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
      }

      template&lt;typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code)&gt;
	async_wait(wait_type __w, _CompletionToken&amp;&amp; __token)
	{
	  async_completion&lt;_CompletionToken, void(error_code)&gt; __init{__token};
	  get_executor().context().async_wait( native_handle(),
	      static_cast&lt;int&gt;(__w),
	      [__h = std::move(__init.completion_handler)]
              (error_code __ec) mutable {
		  __h(__ec);
	      });
	  return __init.result.get();
	}

    protected:
      // construct / copy / destroy:

      using __base::__base;

      explicit
      basic_socket(io_context&amp; __ctx) : __base(__ctx) { }

      basic_socket(io_context&amp; __ctx, const protocol_type&amp; __protocol)
      : __base(__ctx)
      { open(__protocol); }

      basic_socket(io_context&amp; __ctx, const endpoint_type&amp; __endpoint)
      : basic_socket(__ctx, __endpoint.protocol())
      { bind(__endpoint); }

      basic_socket(io_context&amp; __ctx, const protocol_type&amp; __protocol,
		   const native_handle_type&amp; __native_socket)
      : __base(__ctx)
      { assign(__protocol, __native_socket); }

      basic_socket(const basic_socket&amp;) = delete;

      basic_socket(basic_socket&amp;&amp; __rhs) = default;

      template&lt;typename _OtherProtocol, typename _Requires
	       = _Require&lt;is_convertible&lt;_OtherProtocol, _Protocol&gt;&gt;&gt;
	basic_socket(basic_socket&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	: __base(std::move(__rhs)) { }

      ~basic_socket() = default;

      basic_socket&amp; operator=(const basic_socket&amp;) = delete;

      basic_socket&amp; operator=(basic_socket&amp;&amp; __rhs) = default;

      template&lt;typename _OtherProtocol&gt;
	enable_if_t&lt;is_convertible&lt;_OtherProtocol, _Protocol&gt;::value,
		    basic_socket&amp;&gt;
	operator=(basic_socket&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
        { return *this = basic_socket{std::move(__rhs)}; }
    };

  template&lt;typename _Protocol&gt;
    class basic_datagram_socket : public basic_socket&lt;_Protocol&gt;
    {
      using __base = basic_socket&lt;_Protocol&gt;;

    public:
      // types:

      using native_handle_type = int;
      using protocol_type = _Protocol;
      using endpoint_type = typename protocol_type::endpoint;

      // construct / copy / destroy:

      explicit
      basic_datagram_socket(io_context&amp; __ctx) : __base(__ctx) { }

      basic_datagram_socket(io_context&amp; __ctx, const protocol_type&amp; __protocol)
      : __base(__ctx, __protocol) { }

      basic_datagram_socket(io_context&amp; __ctx, const endpoint_type&amp; __endpoint)
      : __base(__ctx, __endpoint) { }

      basic_datagram_socket(io_context&amp; __ctx, const protocol_type&amp; __protocol,
			    const native_handle_type&amp; __native_socket)
      : __base(__ctx, __protocol, __native_socket) { }

      basic_datagram_socket(const basic_datagram_socket&amp;) = delete;

      basic_datagram_socket(basic_datagram_socket&amp;&amp; __rhs) = default;

      template&lt;typename _OtherProtocol, typename _Requires
	       = _Require&lt;is_convertible&lt;_OtherProtocol, _Protocol&gt;&gt;&gt;
	basic_datagram_socket(basic_datagram_socket&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	: __base(std::move(__rhs)) { }

      ~basic_datagram_socket() = default;

      basic_datagram_socket&amp; operator=(const basic_datagram_socket&amp;) = delete;

      basic_datagram_socket&amp; operator=(basic_datagram_socket&amp;&amp; __rhs) = default;

      template&lt;typename _OtherProtocol&gt;
	enable_if_t&lt;is_convertible&lt;_OtherProtocol, _Protocol&gt;::value,
		    basic_datagram_socket&amp;&gt;
	operator=(basic_datagram_socket&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	{
	  __base::operator=(std::move(__rhs));
	  return *this;
	}

      // basic_datagram_socket operations:

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers)
	{
	  return receive(__buffers, socket_base::message_flags(),
			 __throw_on_error{&quot;basic_datagram_socket::receive&quot;});
	}

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers, error_code&amp; __ec)
        { return receive(__buffers, socket_base::message_flags(), __ec); }

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers,
		       socket_base::message_flags __flags)
	{
	  return receive(__buffers, __flags,
			 __throw_on_error{&quot;basic_datagram_socket::receive&quot;});
	}

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers,
		socket_base::message_flags __flags, error_code&amp; __ec)
	{
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  socket_base::__msg_hdr __msg(__buffers);
	  ssize_t __result = ::recvmsg(this-&gt;native_handle(), &amp;__msg,
				       static_cast&lt;int&gt;(__flags));
	  if (__result == -1)
            {
              __ec.assign(errno, generic_category());
              return 0;
            }
          __ec.clear();
          return __result;
#else
	  __ec = std::make_error_code(errc::operation_not_supported);
	  return 0;
#endif
	}

      template&lt;typename _MutableBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_receive(const _MutableBufferSequence&amp; __buffers,
		      _CompletionToken&amp;&amp; __token)
	{
	  return async_receive(__buffers, socket_base::message_flags(),
			       std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;typename _MutableBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_receive(const _MutableBufferSequence&amp; __buffers,
		      socket_base::message_flags __flags,
		      _CompletionToken&amp;&amp; __token)
	{
          async_completion&lt;_CompletionToken, void(error_code, size_t)&gt;
            __init{__token};

	  this-&gt;get_executor().context().async_wait(this-&gt;native_handle(),
	      (int) socket_base::wait_read,
	      [__h = std::move(__init.completion_handler),
               &amp;__buffers, __flags = static_cast&lt;int&gt;(__flags),
               __fd = this-&gt;native_handle()]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec);
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  socket_base::__msg_hdr __msg(__buffers);
                  ssize_t __result = ::recvmsg(__fd, &amp;__msg, __flags);
                  if (__result == -1)
                    {
                      __ec.assign(errno, generic_category());
                      __result = 0;
                    }
                  else
                    __ec.clear();
		  __h(__ec, __result);
#else
		  __h(std::make_error_code(errc::operation_not_supported), 0);
#endif
	      });
	  return __init.result.get();
	}

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive_from(const _MutableBufferSequence&amp; __buffers,
		     endpoint_type&amp; __sender)
	{
	  return receive_from(__buffers, __sender,
			      socket_base::message_flags(),
			      __throw_on_error{
				  &quot;basic_datagram_socket::receive_from&quot;});
	}

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive_from(const _MutableBufferSequence&amp; __buffers,
		     endpoint_type&amp; __sender, error_code&amp; __ec)
	{
	  return receive_from(__buffers, __sender,
			      socket_base::message_flags(), __ec);
	}

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive_from(const _MutableBufferSequence&amp; __buffers,
		     endpoint_type&amp; __sender,
		     socket_base::message_flags __flags)
	{
	  return receive_from(__buffers, __sender, __flags,
			      __throw_on_error{
				  &quot;basic_datagram_socket::receive_from&quot;});
	}

      template&lt;typename _MutableBufferSequence&gt;
	size_t
	receive_from(const _MutableBufferSequence&amp; __buffers,
		     endpoint_type&amp; __sender,
		     socket_base::message_flags __flags,
		     error_code&amp; __ec)
	{
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  socket_base::__msg_hdr __msg(__buffers, __sender);
	  ssize_t __result = ::recvmsg(this-&gt;native_handle(), &amp;__msg,
				       static_cast&lt;int&gt;(__flags));
	  if (__result == -1)
            {
              __ec.assign(errno, generic_category());
              return 0;
            }
          __ec.clear();
          __sender.resize(__msg.msg_namelen);
          return __result;
#else
	  __ec = std::make_error_code(errc::operation_not_supported);
	  return 0;
#endif
	}

      template&lt;typename _MutableBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_receive_from(const _MutableBufferSequence&amp; __buffers,
			   endpoint_type&amp; __sender,
			   _CompletionToken&amp;&amp; __token)
	{
	  return async_receive_from(__buffers, __sender,
				    socket_base::message_flags(),
				    std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;typename _MutableBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_receive_from(const _MutableBufferSequence&amp; __buffers,
			   endpoint_type&amp; __sender,
			   socket_base::message_flags __flags,
			   _CompletionToken&amp;&amp; __token)
	{
	  async_completion&lt;_CompletionToken, void(error_code, size_t)&gt;
            __init{__token};

	  this-&gt;get_executor().context().async_wait( this-&gt;native_handle(),
	      (int) socket_base::wait_read,
	      [__h = std::move(__init.completion_handler),
               &amp;__buffers, __flags = static_cast&lt;int&gt;(__flags),
               __sender = std::move(__sender),
               __fd = this-&gt;native_handle()]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec);
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  socket_base::__msg_hdr __msg(__buffers, __sender);
                  ssize_t __result = ::recvmsg(__fd, &amp;__msg, __flags);
                  if (__result == -1)
                    {
                      __ec.assign(errno, generic_category());
                      __result = 0;
                    }
                  else
                    {
                      __ec.clear();
                      __sender.resize(__msg.msg_namelen);
                    }
		  __h(__ec, __result);
#else
		  __h(std::make_error_code(errc::operation_not_supported), 0);
#endif
	      });
	  return __init.result.get();
	}

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers)
	{
	  return send(__buffers, socket_base::message_flags(),
		      __throw_on_error{&quot;basic_datagram_socket::send&quot;});
	}

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers, error_code&amp; __ec)
	{ return send(__buffers, socket_base::message_flags(), __ec); }

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers,
	     socket_base::message_flags __flags)
	{
	  return send(__buffers, __flags,
		      __throw_on_error{&quot;basic_datagram_socket::send&quot;});
	}

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers,
	     socket_base::message_flags __flags, error_code&amp; __ec)
	{
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  socket_base::__msg_hdr __msg(__buffers);
	  ssize_t __result = ::sendmsg(this-&gt;native_handle(), &amp;__msg,
				       static_cast&lt;int&gt;(__flags));
	  if (__result == -1)
            {
              __ec.assign(errno, generic_category());
              return 0;
            }
          __ec.clear();
          return __result;
#else
	  __ec = std::make_error_code(errc::operation_not_supported);
	  return 0;
#endif
	}

      template&lt;typename _ConstBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_send(const _ConstBufferSequence&amp; __buffers,
			_CompletionToken&amp;&amp; __token)
	{
	  return async_send(__buffers, socket_base::message_flags(),
			    std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;typename _ConstBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_send(const _ConstBufferSequence&amp; __buffers,
		   socket_base::message_flags __flags,
		   _CompletionToken&amp;&amp; __token)
	{
	  async_completion&lt;_CompletionToken, void(error_code, size_t)&gt;
            __init{__token};

	  this-&gt;get_executor().context().async_wait( this-&gt;native_handle(),
	      (int) socket_base::wait_write,
	      [__h = std::move(__init.completion_handler),
               &amp;__buffers, __flags = static_cast&lt;int&gt;(__flags),
               __fd = this-&gt;native_handle()]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec);
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  socket_base::__msg_hdr __msg(__buffers);
                  ssize_t __result = ::sendmsg(__fd, &amp;__msg, __flags);
                  if (__result == -1)
                    {
                      __ec.assign(errno, generic_category());
                      __result = 0;
                    }
                  else
                    __ec.clear();
		  __h(__ec, __result);
#else
		  __h(std::make_error_code(errc::operation_not_supported), 0);
#endif
	      });
	  return __init.result.get();
	}

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send_to(const _ConstBufferSequence&amp; __buffers,
	        const endpoint_type&amp; __recipient)
	{
	  return send_to(__buffers, __recipient,
			 socket_base::message_flags(),
			 __throw_on_error{&quot;basic_datagram_socket::send_to&quot;});
	}

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send_to(const _ConstBufferSequence&amp; __buffers,
		const endpoint_type&amp; __recipient, error_code&amp; __ec)
	{
	  return send_to(__buffers, __recipient,
			 socket_base::message_flags(), __ec);
	}

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send_to(const _ConstBufferSequence&amp; __buffers,
		const endpoint_type&amp; __recipient,
		socket_base::message_flags __flags)
	{
	  return send_to(__buffers, __recipient, __flags,
			 __throw_on_error{&quot;basic_datagram_socket::send_to&quot;});
	}

      template&lt;typename _ConstBufferSequence&gt;
	size_t
	send_to(const _ConstBufferSequence&amp; __buffers,
	        const endpoint_type&amp; __recipient,
		socket_base::message_flags __flags, error_code&amp; __ec)
	{
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  socket_base::__msg_hdr __msg(__buffers, __recipient);
	  ssize_t __result = ::sendmsg(this-&gt;native_handle(), &amp;__msg,
				       static_cast&lt;int&gt;(__flags));
	  if (__result == -1)
            {
              __ec.assign(errno, generic_category());
              return 0;
            }
          __ec.clear();
          __recipient.resize(__msg.msg_namelen);
          return __result;
#else
	  __ec = std::make_error_code(errc::operation_not_supported);
	  return 0;
#endif
	}

      template&lt;typename _ConstBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_send_to(const _ConstBufferSequence&amp; __buffers,
		      const endpoint_type&amp; __recipient,
		      _CompletionToken&amp;&amp; __token)
	{
	  return async_send_to(__buffers, __recipient,
			       socket_base::message_flags(),
			       std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;typename _ConstBufferSequence, typename _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_send_to(const _ConstBufferSequence&amp; __buffers,
		      const endpoint_type&amp; __recipient,
		      socket_base::message_flags __flags,
		      _CompletionToken&amp;&amp; __token)
	{
	  async_completion&lt;_CompletionToken, void(error_code, size_t)&gt;
            __init{__token};

	  this-&gt;get_executor().context().async_wait( this-&gt;native_handle(),
	      (int) socket_base::wait_write,
	      [__h = std::move(__init.completion_handler),
               &amp;__buffers, __flags = static_cast&lt;int&gt;(__flags),
               __recipient = std::move(__recipient),
               __fd = this-&gt;native_handle()]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec);
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  socket_base::__msg_hdr __msg(__buffers, __recipient);
                  ssize_t __result = ::sendmsg(__fd, &amp;__msg, __flags);
                  if (__result == -1)
                    {
                      __ec.assign(errno, generic_category());
                      __result = 0;
                    }
                  else
                    {
                      __ec.clear();
                      __recipient.resize(__msg.msg_namelen);
                    }
		  __h(__ec, __result);
#else
		  __h(std::make_error_code(errc::operation_not_supported), 0);
#endif
	      });
	  return __init.result.get();
	}
    };

  template&lt;typename _Protocol&gt;
    class basic_stream_socket : public basic_socket&lt;_Protocol&gt;
    {
      using __base = basic_socket&lt;_Protocol&gt;;

    public:
      // types:

      using native_handle_type = int;
      using protocol_type = _Protocol;
      using endpoint_type = typename protocol_type::endpoint;

      // construct / copy / destroy:

      explicit
      basic_stream_socket(io_context&amp; __ctx) : __base(__ctx) { }

      basic_stream_socket(io_context&amp; __ctx, const protocol_type&amp; __protocol)
      : __base(__ctx, __protocol) { }

      basic_stream_socket(io_context&amp; __ctx, const endpoint_type&amp; __endpoint)
      : __base(__ctx, __endpoint) { }

      basic_stream_socket(io_context&amp; __ctx, const protocol_type&amp; __protocol,
			  const native_handle_type&amp; __native_socket)
      : __base(__ctx, __protocol, __native_socket) { }

      basic_stream_socket(const basic_stream_socket&amp;) = delete;

      basic_stream_socket(basic_stream_socket&amp;&amp; __rhs) = default;

      template&lt;typename _OtherProtocol, typename _Requires
	       = _Require&lt;is_convertible&lt;_OtherProtocol, _Protocol&gt;&gt;&gt;
	basic_stream_socket(basic_stream_socket&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	: __base(std::move(__rhs)) { }

      ~basic_stream_socket() = default;

      basic_stream_socket&amp; operator=(const basic_stream_socket&amp;) = delete;

      basic_stream_socket&amp; operator=(basic_stream_socket&amp;&amp; __rhs) = default;

      template&lt;class _OtherProtocol&gt;
	enable_if_t&lt;is_convertible&lt;_OtherProtocol, _Protocol&gt;::value,
		    basic_stream_socket&amp;&gt;
	operator=(basic_stream_socket&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	{
	  __base::operator=(std::move(__rhs));
	  return *this;
	}

      // basic_stream_socket operations:

      template&lt;class _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers)
	{
	  return receive(__buffers, socket_base::message_flags(),
			 __throw_on_error{&quot;basic_stream_socket::receive&quot;});
	}

      template&lt;class _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers, error_code&amp; __ec)
        { return receive(__buffers, socket_base::message_flags(), __ec); }

      template&lt;class _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers,
		socket_base::message_flags __flags)
	{
	  return receive(__buffers, __flags,
			 __throw_on_error{&quot;basic_stream_socket::receive&quot;});
	}

      template&lt;class _MutableBufferSequence&gt;
	size_t
	receive(const _MutableBufferSequence&amp; __buffers,
		socket_base::message_flags __flags, error_code&amp; __ec)
	{
	  if (__buffer_empty(__buffers))
	    {
	      __ec.clear();
	      return 0;
	    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  socket_base::__msg_hdr __msg(__buffers);
	  ssize_t __result = ::recvmsg(this-&gt;native_handle(), &amp;__msg,
				       static_cast&lt;int&gt;(__flags));
	  if (__result &gt;= 0)
	    {
	      __ec.clear();
	      return __result;
	    }
	  __ec.assign(errno, generic_category());
#else
	  __ec = std::make_error_code(errc::operation_not_supported);
#endif
	  return 0;
	}

      template&lt;class _MutableBufferSequence, class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_receive(const _MutableBufferSequence&amp; __buffers,
		      _CompletionToken&amp;&amp; __token)
	{
	  return async_receive(__buffers, socket_base::message_flags(),
			       std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;class _MutableBufferSequence, class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_receive(const _MutableBufferSequence&amp; __buffers,
		      socket_base::message_flags __flags,
		      _CompletionToken&amp;&amp; __token)
	{
	  async_completion&lt;_CompletionToken, void(error_code, size_t)&gt;
            __init{__token};

          if (__buffer_empty(__buffers))
	    {
              auto __ex = net::get_associated_executor(
                  __init.completion_handler, this-&gt;get_executor());
              auto __a = get_associated_allocator(
                  __init.completion_handler, std::allocator&lt;void&gt;());
              __ex.post(
                  [__h=std::move(__init.completion_handler)] () mutable
                  { __h(error_code{}, 0); }, __a);
              return __init.result.get();
	    }

          this-&gt;get_executor().context().async_wait(this-&gt;native_handle(),
	      (int) socket_base::wait_read,
	      [__h = std::move(__init.completion_handler),
               &amp;__buffers, __flags = static_cast&lt;int&gt;(__flags),
               __fd = this-&gt;native_handle()]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec);
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  socket_base::__msg_hdr __msg(__buffers);
                  ssize_t __result = ::recvmsg(__fd, &amp;__msg, __flags);
                  if (__result == -1)
                    {
                      __ec.assign(errno, generic_category());
                      __result = 0;
                    }
                  else
                    __ec.clear();
		  __h(__ec, __result);
#else
		  __h(std::make_error_code(errc::operation_not_supported), 0);
#endif
	      });
	  return __init.result.get();
	}

      template&lt;class _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers)
	{
	  return send(__buffers, socket_base::message_flags(),
		      __throw_on_error{&quot;basic_stream_socket::send&quot;});
	}

      template&lt;class _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers, error_code&amp; __ec)
	{ return send(__buffers, socket_base::message_flags(), __ec); }

      template&lt;class _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers,
	     socket_base::message_flags __flags)
	{
	  return send(__buffers, socket_base::message_flags(),
		      __throw_on_error{&quot;basic_stream_socket::send&quot;});
	}

      template&lt;class _ConstBufferSequence&gt;
	size_t
	send(const _ConstBufferSequence&amp; __buffers,
	     socket_base::message_flags __flags, error_code&amp; __ec)
	{
	  if (__buffer_empty(__buffers))
	    {
	      __ec.clear();
	      return 0;
	    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	  socket_base::__msg_hdr __msg(__buffers);
	  ssize_t __result = ::sendmsg(this-&gt;native_handle(), &amp;__msg,
				       static_cast&lt;int&gt;(__flags));
	  if (__result &gt;= 0)
	    {
	      __ec.clear();
	      return __result;
	    }
	  __ec.assign(errno, generic_category());
#else
	  __ec = std::make_error_code(errc::operation_not_supported);
#endif
	  return 0;
	}

      template&lt;class _ConstBufferSequence, class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_send(const _ConstBufferSequence&amp; __buffers,
		   _CompletionToken&amp;&amp; __token)
	{
	  return async_send(__buffers, socket_base::message_flags(),
			    std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;class _ConstBufferSequence, class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_send(const _ConstBufferSequence&amp; __buffers,
		   socket_base::message_flags __flags,
		   _CompletionToken&amp;&amp; __token)
	{
	  async_completion&lt;_CompletionToken, void(error_code, size_t)&gt;
            __init{__token};

          if (__buffer_empty(__buffers))
	    {
              auto __ex = net::get_associated_executor(
                  __init.completion_handler, this-&gt;get_executor());
              auto __a = get_associated_allocator(
                  __init.completion_handler, std::allocator&lt;void&gt;());
              __ex.post(
                  [__h=std::move(__init.completion_handler)] () mutable
                  { __h(error_code{}, 0); }, __a);
              return __init.result.get();
	    }

          this-&gt;get_executor().context().async_wait(this-&gt;native_handle(),
	      (int) socket_base::wait_write,
	      [__h = std::move(__init.completion_handler),
               &amp;__buffers, __flags = static_cast&lt;int&gt;(__flags),
               __fd = this-&gt;native_handle()]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec);
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  socket_base::__msg_hdr __msg(__buffers);
                  ssize_t __result = ::sendmsg(__fd, &amp;__msg, __flags);
                  if (__result == -1)
                    {
                      __ec.assign(errno, generic_category());
                      __result = 0;
                    }
                  else
                    __ec.clear();
		  __h(__ec, __result);
#else
		  __h(std::make_error_code(errc::operation_not_supported), 0);
#endif
	      });
	  return __init.result.get();
	}

      template&lt;class _MutableBufferSequence&gt;
	size_t
	read_some(const _MutableBufferSequence&amp; __buffers)
	{
	  return receive(__buffers,
			 __throw_on_error{&quot;basic_stream_socket::read_some&quot;});
	}

      template&lt;class _MutableBufferSequence&gt;
	size_t
	read_some(const _MutableBufferSequence&amp; __buffers, error_code&amp; __ec)
	{ return receive(__buffers, __ec); }

      template&lt;class _MutableBufferSequence, class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_read_some(const _MutableBufferSequence&amp; __buffers,
			_CompletionToken&amp;&amp; __token)
	{
	  return async_receive(__buffers,
			       std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;class _ConstBufferSequence&gt;
	size_t
	write_some(const _ConstBufferSequence&amp; __buffers)
	{
	  return send(__buffers,
		      __throw_on_error{&quot;basic_stream_socket:write_some&quot;});
	}

      template&lt;class _ConstBufferSequence&gt;
	size_t
	write_some(const _ConstBufferSequence&amp; __buffers, error_code&amp; __ec)
	{  return send(__buffers, __ec); }

      template&lt;class _ConstBufferSequence, class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, size_t)&gt;
	async_write_some(const _ConstBufferSequence&amp; __buffers,
			      _CompletionToken&amp;&amp; __token)
	{
	  return async_send(__buffers,
			    std::forward&lt;_CompletionToken&gt;(__token));
	}
    };

  template&lt;typename _AcceptableProtocol&gt;
    class basic_socket_acceptor
    : public socket_base, private __basic_socket_impl&lt;_AcceptableProtocol&gt;
    {
      using __base = __basic_socket_impl&lt;_AcceptableProtocol&gt;;

    public:
      // types:

      using executor_type = io_context::executor_type;
      using native_handle_type = int;
      using protocol_type = _AcceptableProtocol;
      using endpoint_type = typename protocol_type::endpoint;
      using socket_type = typename protocol_type::socket;

      static_assert(__detail::__acceptable_protocol&lt;protocol_type&gt;,
		    &quot;protocol_type meets the AcceptableProtocol requirements&quot;);

      // construct / copy / destroy:

      explicit
      basic_socket_acceptor(io_context&amp; __ctx)
      : __base(__ctx), _M_protocol(endpoint_type{}.protocol()) { }

      basic_socket_acceptor(io_context&amp; __ctx,
			    const protocol_type&amp; __protocol)
      : __base(__ctx), _M_protocol(__protocol)
      { open(__protocol); }

      basic_socket_acceptor(io_context&amp; __ctx, const endpoint_type&amp; __endpoint,
			    [[__maybe_unused__]] bool __reuse_addr = true)
      : basic_socket_acceptor(__ctx, __endpoint.protocol())
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	if (__reuse_addr)
	  set_option(reuse_address(true));
#endif
	bind(__endpoint);
	listen();
      }

      basic_socket_acceptor(io_context&amp; __ctx, const protocol_type&amp; __protocol,
			    const native_handle_type&amp; __native_acceptor)
      : basic_socket_acceptor(__ctx, __protocol)
      { assign(__protocol, __native_acceptor); }

      basic_socket_acceptor(const basic_socket_acceptor&amp;) = delete;

      basic_socket_acceptor(basic_socket_acceptor&amp;&amp;) = default;

      template&lt;typename _OtherProtocol, typename _Requires
	       = _Require&lt;is_convertible&lt;_OtherProtocol, protocol_type&gt;&gt;&gt;
	basic_socket_acceptor(basic_socket_acceptor&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	: __base(std::move(__rhs)) { }

      ~basic_socket_acceptor() = default;

      basic_socket_acceptor&amp; operator=(const basic_socket_acceptor&amp;) = delete;

      basic_socket_acceptor&amp; operator=(basic_socket_acceptor&amp;&amp;) = default;

      template&lt;class _OtherProtocol&gt;
	enable_if_t&lt;is_convertible&lt;_OtherProtocol, protocol_type&gt;::value,
		    basic_socket_acceptor&amp;&gt;
	operator=(basic_socket_acceptor&lt;_OtherProtocol&gt;&amp;&amp; __rhs)
	{
	  __base::operator=(std::move(__rhs));
	  return *this;
	}

      // basic_socket_acceptor operations:

      executor_type get_executor() noexcept { return __base::get_executor(); }

      native_handle_type
      native_handle() noexcept { return __base::native_handle(); }

      void
      open(const protocol_type&amp; __protocol = protocol_type())
      { open(__protocol, __throw_on_error{&quot;basic_socket_acceptor::open&quot;}); }

      void
      open(const protocol_type&amp; __protocol, error_code&amp; __ec)
      { __base::open(__protocol, __ec); }

      void
      assign(const protocol_type&amp; __protocol,
	     const native_handle_type&amp; __native_acceptor)
      {
	assign(__protocol, __native_acceptor,
	       __throw_on_error{&quot;basic_socket_acceptor::assign&quot;});
      }

      void
      assign(const protocol_type&amp; __protocol,
	     const native_handle_type&amp; __native_acceptor,
	     error_code&amp; __ec)
      { __base::assign(__protocol, __native_acceptor, __ec); }

      native_handle_type release()
      { return release(__throw_on_error{&quot;basic_socket_acceptor::release&quot;}); }

      native_handle_type release(error_code&amp; __ec)
      { return __base::release(__ec); }

      _GLIBCXX_NODISCARD bool
      is_open() const noexcept { return __base::is_open(); }

      void
      close() { close(__throw_on_error{&quot;basic_socket_acceptor::close&quot;}); }

      void
      close(error_code&amp; __ec) { __base::_close(__ec); }

      void
      cancel() { cancel(__throw_on_error{&quot;basic_socket_acceptor::cancel&quot;}); }

      void
      cancel(error_code&amp; __ec) { __base::cancel(__ec); }

      template&lt;typename _SettableSocketOption&gt;
	void
	set_option(const _SettableSocketOption&amp; __option)
	{
	  set_option(__option,
		     __throw_on_error{&quot;basic_socket_acceptor::set_option&quot;});
	}

      template&lt;typename _SettableSocketOption&gt;
	void
	set_option(const _SettableSocketOption&amp; __option, error_code&amp; __ec)
	{ __base::set_option(__option, __ec); }

      template&lt;typename _GettableSocketOption&gt;
	void
	get_option(_GettableSocketOption&amp; __option) const
	{
	  get_option(__option,
		     __throw_on_error{&quot;basic_socket_acceptor::get_option&quot;});
	}

      template&lt;typename _GettableSocketOption&gt;
	void
	get_option(_GettableSocketOption&amp; __option, error_code&amp; __ec) const
	{ __base::get_option(__option, __ec); }

      template&lt;typename _IoControlCommand&gt;
	void
	io_control(_IoControlCommand&amp; __command)
	{
	  io_control(__command,
		     __throw_on_error{&quot;basic_socket_acceptor::io_control&quot;});
	}

      template&lt;typename _IoControlCommand&gt;
	void
	io_control(_IoControlCommand&amp; __command, error_code&amp; __ec)
	{ __base::io_control(__command, __ec); }

      void
      non_blocking(bool __mode)
      {
	non_blocking(__mode,
		     __throw_on_error{&quot;basic_socket_acceptor::non_blocking&quot;});
      }

      void
      non_blocking(bool __mode, error_code&amp; __ec)
      { __base::non_blocking(__mode, __ec); }

      bool non_blocking() const { return __base::non_blocking(); }

      void
      native_non_blocking(bool __mode)
      {
	native_non_blocking(__mode, __throw_on_error{
	    &quot;basic_socket_acceptor::native_non_blocking&quot;});
      }

      void
      native_non_blocking(bool __mode, error_code&amp; __ec)
      { __base::native_non_blocking(__mode, __ec); }

      bool
      native_non_blocking() const
      { return __base::native_non_blocking(); }

      void
      bind(const endpoint_type&amp; __endpoint)
      {
	return bind(__endpoint,
		    __throw_on_error{&quot;basic_socket_acceptor::bind&quot;});
      }

      void
      bind(const endpoint_type&amp; __endpoint, error_code&amp; __ec)
      { __base::bind(__endpoint, __ec); }

      void
      listen(int __backlog = max_listen_connections)
      {
	return listen(__backlog,
		      __throw_on_error{&quot;basic_socket_acceptor::listen&quot;});
      }

      void
      listen(int __backlog, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	if (::listen(native_handle(), __backlog) == -1)
	  __ec.assign(errno, generic_category());
	else
	  __ec.clear();
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
      }

      endpoint_type
      local_endpoint() const
      {
	return local_endpoint(
	    __throw_on_error{&quot;basic_socket_acceptor::local_endpoint&quot;});
      }

      endpoint_type
      local_endpoint(error_code&amp; __ec) const
      { return __base::local_endpoint(__ec); }

      void
      enable_connection_aborted(bool __mode)
      { __base::_M_bits.enable_connection_aborted = __mode; }

      bool
      enable_connection_aborted() const
      { return __base::_M_bits.enable_connection_aborted; }

      socket_type
      accept()
      { return accept(__throw_on_error{&quot;basic_socket_acceptor::accept&quot;}); }

      socket_type
      accept(error_code&amp; __ec)
      { return accept(get_executor().context(), __ec); }

      socket_type accept(io_context&amp; __ctx)
      {
	return accept(__ctx,
		      __throw_on_error{&quot;basic_socket_acceptor::accept&quot;});
      }

      socket_type
      accept(io_context&amp; __ctx, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	do
	  {
	    int __h = ::accept(native_handle(), nullptr, 0);
	    if (__h != -1)
	      {
		__ec.clear();
		return socket_type{__ctx, _M_protocol, __h};
	      }
	  } while (errno == ECONNABORTED &amp;&amp; enable_connection_aborted());
	__ec.assign(errno, generic_category());
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
	return socket_type{__ctx};
      }

      template&lt;class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, socket_type)&gt;
	async_accept(_CompletionToken&amp;&amp; __token)
	{
	  return async_accept(get_executor().context(),
			      std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, socket_type)&gt;
	async_accept(io_context&amp; __ctx, _CompletionToken&amp;&amp; __token)
	{
          async_completion&lt;_CompletionToken, void(error_code, socket_type)&gt;
            __init{__token};

	  __ctx.async_wait(native_handle(),
	      (int) socket_base::wait_read,
	      [__h = std::move(__init.completion_handler),
               __connabort = enable_connection_aborted(),
               __fd = native_handle(),
               __protocol = _M_protocol,
               &amp;__ctx
              ]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec, socket_type(__ctx));
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  do
                    {
                      int __newfd = ::accept(__fd, nullptr, 0);
                      if (__newfd != -1)
                        {
                          __ec.clear();
                          __h(__ec, socket_type{__ctx, __protocol, __newfd});
                          return;
                        }
                    } while (errno == ECONNABORTED &amp;&amp; __connabort);
                  __ec.assign(errno, generic_category());
                  __h(__ec, socket_type(__ctx));
#else
		  __h(std::make_error_code(errc::operation_not_supported), 0);
#endif
	      });
	  return __init.result.get();
	}

      socket_type
      accept(endpoint_type&amp; __endpoint)
      {
	return accept(get_executor().context(), __endpoint,
		      __throw_on_error{&quot;basic_socket_acceptor::accept&quot;});
      }

      socket_type
      accept(endpoint_type&amp; __endpoint, error_code&amp; __ec)
      { return accept(get_executor().context(), __endpoint, __ec); }

      socket_type
      accept(io_context&amp; __ctx, endpoint_type&amp; __endpoint)
      {
	return accept(__ctx, __endpoint,
		      __throw_on_error{&quot;basic_socket_acceptor::accept&quot;});
      }

      socket_type
      accept(io_context&amp; __ctx, endpoint_type&amp; __endpoint, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
	do
	  {
	    socklen_t __len = __endpoint.capacity();
	    int __h = ::accept(native_handle(), (sockaddr*)__endpoint.data(),
			       &amp;__len);
	    if (__h != -1)
	      {
		__endpoint.resize(__len);
		return socket_type{__ctx, _M_protocol, __h};
	      }
	  } while (errno == ECONNABORTED &amp;&amp; enable_connection_aborted());
	__ec.assign(errno, generic_category());
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
	return socket_type{__ctx};
      }

      template&lt;class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, socket_type)&gt;
	async_accept(endpoint_type&amp; __endpoint,
			     _CompletionToken&amp;&amp; __token)
	{
	  return async_accept(get_executor().context(), __endpoint,
			      std::forward&lt;_CompletionToken&gt;(__token));
	}

      template&lt;class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code, socket_type)&gt;
	async_accept(io_context&amp; __ctx, endpoint_type&amp; __endpoint,
			     _CompletionToken&amp;&amp; __token)
        {
          async_completion&lt;_CompletionToken, void(error_code, socket_type)&gt;
            __init{__token};

	  __ctx.async_wait(native_handle(),
	      (int) socket_base::wait_read,
	      [__h = std::move(__init.completion_handler),
              __ep = std::move(__endpoint),
               __connabort = enable_connection_aborted(),
               __fd = native_handle(),
               &amp;__ctx
              ]
              (error_code __ec) mutable {
                  if (__ec)
                    {
                      __h(__ec, socket_type(__ctx));
                      return;
                    }
#ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
                  do
                    {
                      socklen_t __len = __ep.capacity();
                      int __newfd = ::accept(__fd, __ep.data, &amp;__len);
                      if (__newfd != -1)
                        {
                          __ep.resize(__len);
                          auto __protocol = __ep.protocol();
                          __ec.clear();
                          __h(__ec, socket_type{__ctx, __protocol, __newfd});
                          return;
                        }
                    } while (errno == ECONNABORTED &amp;&amp; __connabort);
                  __ec.assign(errno, generic_category());
#else
		  __ec = std::make_error_code(errc::operation_not_supported);
#endif
                  __h(__ec, socket_type(__ctx));
	      });
	  return __init.result.get();
        }

      void
      wait(wait_type __w)
      { wait(__w, __throw_on_error{&quot;basic_socket_acceptor::wait&quot;}); }

      void
      wait(wait_type __w, error_code&amp; __ec)
      {
#ifdef _GLIBCXX_HAVE_POLL_H
	::pollfd __fds;
	__fds.fd = native_handle();
	__fds.events = __w; // __w | POLLIN;
	if (::poll(&amp;__fds, 1, -1) == -1)
	  __ec.assign(errno, generic_category());
	else
	  __ec.clear();
#else
	__ec = std::make_error_code(errc::operation_not_supported);
#endif
      }

      template&lt;class _CompletionToken&gt;
	__deduced_t&lt;_CompletionToken, void(error_code)&gt;
	async_wait(wait_type __w, _CompletionToken&amp;&amp; __token)
        {
	  async_completion&lt;_CompletionToken, void(error_code)&gt; __init{__token};
	  get_executor().context().async_wait( native_handle(),
	      static_cast&lt;int&gt;(__w),
	      [__h = std::move(__init.completion_handler)]
              (error_code __ec) mutable {
		  __h(__ec);
	      });
	  return __init.result.get();
	}

    private:
      protocol_type _M_protocol;
    };

  /// @}

  /** @brief Socket streams
   * @{
   */

  template&lt;typename _Protocol, typename _Clock, typename _WaitTraits&gt;
    class basic_socket_streambuf : public basic_streambuf&lt;char&gt;
    {
    public:
      // types:

      using protocol_type = _Protocol;
      using endpoint_type = typename protocol_type::endpoint;
      using clock_type = _Clock;
      using time_point = typename clock_type::time_point;
      using duration = typename clock_type::duration;
      using wait_traits_type = _WaitTraits;

      // construct / copy / destroy:

      basic_socket_streambuf() : _M_socket(_S_ctx()) { }

      explicit
      basic_socket_streambuf(basic_stream_socket&lt;protocol_type&gt; __s)
      : _M_socket(std::move(__s)) { }

      basic_socket_streambuf(const basic_socket_streambuf&amp;) = delete;

      basic_socket_streambuf(basic_socket_streambuf&amp;&amp; __rhs); // TODO


      virtual ~basic_socket_streambuf(); // TODO

      basic_socket_streambuf&amp; operator=(const basic_socket_streambuf&amp;) = delete;

      basic_socket_streambuf&amp; operator=(basic_socket_streambuf&amp;&amp; __rhs); // TODO

      // members:

      basic_socket_streambuf* connect(const endpoint_type&amp; __e); // TODO

      template&lt;typename... _Args&gt;
	basic_socket_streambuf* connect(_Args&amp;&amp;... ); // TODO

      basic_socket_streambuf* close(); // TODO

      basic_socket&lt;protocol_type&gt;&amp; socket() { return _M_socket; }

      error_code error() const noexcept { return _M_ec; }

      time_point expiry() const { return _M_expiry; }

      void
      expires_at(const time_point&amp; __t)
      { _M_expiry = __t; }

      void
      expires_after(const duration&amp; __d)
      { expires_at(clock_type::now() + __d); }

    protected:
      // overridden virtual functions: // TODO
      virtual int_type underflow() override;
      virtual int_type pbackfail(int_type __c = traits_type::eof()) override;
      virtual int_type overflow(int_type __c = traits_type::eof()) override;
      virtual int sync() override;
      virtual streambuf* setbuf(char_type* __s, streamsize __n) override;

    private:
      static io_context&amp;
      _S_ctx()
      {
	static io_context __ctx;
	return __ctx;
      }

      basic_stream_socket&lt;protocol_type&gt; _M_socket;
      error_code _M_ec;
      time_point _M_expiry{ time_point::max() };
    };

  template&lt;typename _Protocol, class _Clock, typename _WaitTraits&gt;
    class basic_socket_iostream : public basic_iostream&lt;char&gt;
    {
      using __streambuf_type
	= basic_socket_streambuf&lt;_Protocol, _Clock, _WaitTraits&gt;;

    public:
      // types:

      using protocol_type = _Protocol;
      using endpoint_type = typename protocol_type::endpoint;
      using clock_type = _Clock;
      using time_point = typename clock_type::time_point;
      using duration = typename clock_type::duration;
      using wait_traits_type = _WaitTraits;

      // construct / copy / destroy:

      // TODO base-from-member ?
      basic_socket_iostream() : basic_iostream(nullptr), _M_sb()
      {
	this-&gt;init(std::addressof(_M_sb));
	this-&gt;setf(std::ios::unitbuf);
      }

      explicit
      basic_socket_iostream(basic_stream_socket&lt;protocol_type&gt; __s)
      : basic_iostream(nullptr), _M_sb(std::move(__s))
      {
	this-&gt;init(std::addressof(_M_sb));
	this-&gt;setf(std::ios::unitbuf);
      }

      basic_socket_iostream(const basic_socket_iostream&amp;) = delete;

      basic_socket_iostream(basic_socket_iostream&amp;&amp; __rhs)
      : basic_iostream(nullptr), _M_sb(std::move(__rhs._M_sb))
	// XXX ???     ^^^^^^^
      {
	// XXX ??? this-&gt;init(std::addressof(_M_sb));
	this-&gt;set_rbduf(std::addressof(_M_sb));
      }

      template&lt;typename... _Args&gt;
	explicit
	basic_socket_iostream(_Args&amp;&amp;... __args)
	: basic_iostream(nullptr), _M_sb()
	{
	  this-&gt;init(std::addressof(_M_sb));
	  this-&gt;setf(std::ios::unitbuf);
	  connect(forward&lt;_Args&gt;(__args)...);
	}

      basic_socket_iostream&amp; operator=(const basic_socket_iostream&amp;) = delete;

      basic_socket_iostream&amp; operator=(basic_socket_iostream&amp;&amp; __rhs); // TODO

      // members:

      template&lt;typename... _Args&gt;
	void
	connect(_Args&amp;&amp;... __args)
	{
	  if (rdbuf()-&gt;connect(forward&lt;_Args&gt;(__args)...) == nullptr)
	    this-&gt;setstate(failbit);
	}

      void
      close()
      {
	if (rdbuf()-&gt;close() == nullptr)
	  this-&gt;setstate(failbit);
      }

      basic_socket_streambuf&lt;protocol_type, clock_type, wait_traits_type&gt;*
      rdbuf() const
      { return const_cast&lt;__streambuf_type*&gt;(std::addressof(_M_sb)); }

      basic_socket&lt;protocol_type&gt;&amp; socket() { return rdbuf()-&gt;socket(); }
      error_code error() const noexcept { return rdbuf()-&gt;error(); }

      time_point expiry() const { return rdbuf()-&gt;expiry(); }
      void expires_at(const time_point&amp; __t) { rdbuf()-&gt;expires_at(__t); }
      void expires_after(const duration&amp; __d) { rdbuf()-&gt;expires_after(__d); }

    private:
      __streambuf_type _M_sb;
    };

  /// @}

  /** @brief synchronous connect operations
   * @{
   */

  template&lt;typename _Protocol, typename _EndpointSequence,
	   typename _ConnectCondition&gt;
    inline typename _Protocol::endpoint
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    const _EndpointSequence&amp; __endpoints,
	    _ConnectCondition __c, error_code&amp; __ec)
    {
      __ec.clear();
      bool __found = false;
      for (auto&amp; __ep : __endpoints)
	{
	  if (__c(__ec, __ep))
	    {
	      __found = true;
	      __s.close(__ec);
	      if (!__ec)
		__s.open(__ep.protocol(), __ec);
	      if (!__ec)
		__s.connect(__ep, __ec);
	      if (!__ec)
		return __ep;
	    }
	}
      if (!__found)
	__ec = socket_errc::not_found;
      return typename _Protocol::endpoint{};
    }

  template&lt;typename _Protocol, typename _InputIterator,
	   typename _ConnectCondition&gt;
    inline _InputIterator
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    _InputIterator __first, _InputIterator __last,
	    _ConnectCondition __c, error_code&amp; __ec)
    {
      __ec.clear();
      bool __found = false;
      for (auto __i = __first; __i != __last; ++__i)
	{
	  if (__c(__ec, *__i))
	    {
	      __found = true;
	      __s.close(__ec);
	      if (!__ec)
		__s.open(typename _Protocol::endpoint(*__i).protocol(), __ec);
	      if (!__ec)
		__s.connect(*__i, __ec);
	      if (!__ec)
		return __i;
	    }
	}
      if (!__found)
	__ec = socket_errc::not_found;
      return __last;
    }

  template&lt;typename _Protocol, typename _EndpointSequence,
	   typename _ConnectCondition&gt;
    inline typename _Protocol::endpoint
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    const _EndpointSequence&amp; __endpoints,
	    _ConnectCondition __c)
    {
      return net::connect(__s, __endpoints, __c, __throw_on_error{&quot;connect&quot;});
    }

  template&lt;typename _Protocol, typename _InputIterator,
	   typename _ConnectCondition&gt;
    inline _InputIterator
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    _InputIterator __first, _InputIterator __last,
	    _ConnectCondition __c)
    {
      return net::connect(__s, __first, __last, __c,
			  __throw_on_error{&quot;connect&quot;});
    }

  template&lt;typename _Protocol, typename _EndpointSequence&gt;
    inline typename _Protocol::endpoint
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    const _EndpointSequence&amp; __endpoints)
    {
      return net::connect(__s, __endpoints, [](auto, auto){ return true; },
			  __throw_on_error{&quot;connect&quot;});
    }

  template&lt;typename _Protocol, typename _EndpointSequence&gt;
    inline typename _Protocol::endpoint
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    const _EndpointSequence&amp; __endpoints,
	    error_code&amp; __ec)
    {
      return net::connect(__s, __endpoints, [](auto, auto){ return true; },
			  __ec);
    }

  template&lt;typename _Protocol, typename _InputIterator&gt;
    inline _InputIterator
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    _InputIterator __first, _InputIterator __last)
    {
      return net::connect(__s, __first, __last, [](auto, auto){ return true; },
			  __throw_on_error{&quot;connect&quot;});
    }

  template&lt;typename _Protocol, typename _InputIterator&gt;
    inline _InputIterator
    connect(basic_socket&lt;_Protocol&gt;&amp; __s,
	    _InputIterator __first, _InputIterator __last,
	    error_code&amp; __ec)
    {
      return net::connect(__s, __first, __last, [](auto, auto){ return true; },
			  __ec);
    }

  /// @}

  /** @brief asynchronous connect operations
   * @{
   */

  template&lt;typename _Protocol, typename _EndpointSequence,
	   typename _ConnectCondition, typename _CompletionToken&gt;
    inline
    __deduced_t&lt;_CompletionToken,
		void(error_code, typename _Protocol::endpoint)&gt;
    async_connect(basic_socket&lt;_Protocol&gt;&amp; __s,
		  const _EndpointSequence&amp; __endpoints,
		  _ConnectCondition __c, _CompletionToken&amp;&amp; __token); // TODO

  template&lt;typename _Protocol, typename _EndpointSequence,
	   typename _CompletionToken&gt;
    inline
    __deduced_t&lt;_CompletionToken,
		void(error_code, typename _Protocol::endpoint)&gt;
    async_connect(basic_socket&lt;_Protocol&gt;&amp; __s,
		  const _EndpointSequence&amp; __endpoints,
		  _CompletionToken&amp;&amp; __token)
    {
      return net::async_connect(__s, __endpoints,
				[](auto, auto){ return true; },
				forward&lt;_CompletionToken&gt;(__token));
    }

  template&lt;typename _Protocol, typename _InputIterator,
	   typename _ConnectCondition, typename _CompletionToken&gt;
    inline
    __deduced_t&lt;_CompletionToken, void(error_code, _InputIterator)&gt;
    async_connect(basic_socket&lt;_Protocol&gt;&amp; __s,
		  _InputIterator __first, _InputIterator __last,
		  _ConnectCondition __c, _CompletionToken&amp;&amp; __token); // TODO

  template&lt;typename _Protocol, typename _InputIterator,
	   typename _CompletionToken&gt;
    inline
    __deduced_t&lt;_CompletionToken, void(error_code, _InputIterator)&gt;
    async_connect(basic_socket&lt;_Protocol&gt;&amp; __s,
		  _InputIterator __first, _InputIterator __last,
		  _CompletionToken&amp;&amp; __token)
    {
      return net::async_connect(__s, __first, __last,
				[](auto, auto){ return true; },
				forward&lt;_CompletionToken&gt;(__token));
    }

  /// @}

#endif  // _GLIBCXX_HAVE_UNISTD_H

  /// @}

} // namespace v1
} // namespace net
} // namespace experimental

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++14

#endif // _GLIBCXX_EXPERIMENTAL_SOCKET
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11%2Fexperimental'>Back to Directory</a>