libstdc++-v3/include/experimental/socket

   1 // <experimental/socket> -*- C++ -*-
   2
   3 // Copyright (C) 2015-2024 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file experimental/socket
  26  *  This is a TS C++ Library header.
  27  *  @ingroup networking-ts
  28  */
  29
  30 #ifndef _GLIBCXX_EXPERIMENTAL_SOCKET
  31 #define _GLIBCXX_EXPERIMENTAL_SOCKET
  32
  33 #pragma GCC system_header
  34
  35 #include <bits/requires_hosted.h> // experimental is currently omitted
  36
  37 #if __cplusplus >= 201402L
  38
  39 #include <experimental/netfwd>
  40 #include <experimental/buffer>
  41 #include <experimental/io_context>
  42 #include <experimental/bits/net.h>
  43 #include <streambuf>
  44 #include <istream>
  45 #include <bits/unique_ptr.h>
  46 #if _GLIBCXX_HAVE_UNISTD_H
  47 # include <unistd.h>
  48 # ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
  49 #  include <sys/socket.h>       // socket etc
  50 # endif
  51 # ifdef _GLIBCXX_HAVE_SYS_IOCTL_H
  52 #  include <sys/ioctl.h>        // ioctl
  53 # endif
  54 # ifdef _GLIBCXX_HAVE_SYS_UIO_H
  55 #  include <sys/uio.h>          // iovec
  56 # endif
  57 # ifdef _GLIBCXX_HAVE_POLL_H
  58 #  include <poll.h>             // poll, pollfd, POLLIN, POLLOUT, POLLERR
  59 # endif
  60 # ifdef _GLIBCXX_HAVE_FCNTL_H
  61 #  include <fcntl.h>            // fcntl, F_GETFL, F_SETFL
  62 # endif
  63 #endif
  64
  65 namespace std _GLIBCXX_VISIBILITY(default)
  66 {
  67 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  68 namespace experimental
  69 {
  70 namespace net
  71 {
  72 inline namespace v1
  73 {
  74
  75   /** @addtogroup networking-ts
  76    *  @{
  77    */
  78
  79   enum class socket_errc {  // TODO decide values
  80     already_open = 3,
  81     not_found = 4
  82   };
  83
  84 } // namespace v1
  85 } // namespace net
  86 } // namespace experimental
  87
  88   template<>
  89     struct is_error_code_enum<experimental::net::v1::socket_errc>
  90     : public true_type {};
  91
  92 namespace experimental
  93 {
  94 namespace net
  95 {
  96 inline namespace v1
  97 {
  98   const error_category& socket_category() noexcept
  99   {
 100     struct __cat : error_category
 101     {
 102       const char* name() const noexcept { return "socket"; }
 103
 104       std::string message(int __e) const
 105       {
 106         if (__e == (int)socket_errc::already_open)
 107           return "already open";
 108         else if (__e == (int)socket_errc::not_found)
 109           return "endpoint not found";
 110         return "socket error";
 111       }
 112
 113       virtual void __message(int) { } // TODO dual ABI XXX
 114     };
 115     static __cat __c;
 116     return __c;
 117   }
 118
 119   inline error_code
 120   make_error_code(socket_errc __e) noexcept
 121   { return error_code(static_cast<int>(__e), socket_category()); }
 122
 123   inline error_condition
 124   make_error_condition(socket_errc __e) noexcept
 125   { return error_condition(static_cast<int>(__e), socket_category()); }
 126
 127
 128   // TODO GettableSocket reqs
 129   // TODO SettableSocket reqs
 130   // TODO BooleanSocketOption reqs
 131   // TODO IntegerSocketOption reqs
 132   // TODO IoControlCommand reqs
 133   // TODO ConnectCondition reqs
 134
 135   /** @brief Sockets
 136    * @{
 137    */
 138
 139   class socket_base
 140   {
 141   public:
 142 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 143     class broadcast : public __sockopt_crtp<broadcast, bool>
 144     {
 145     public:
 146       using __sockopt_crtp::__sockopt_crtp;
 147       using __sockopt_crtp::operator=;
 148
 149     private:
 150       friend __sockopt_crtp<broadcast, bool>;
 151       static const int _S_level = SOL_SOCKET;
 152       static const int _S_name = SO_BROADCAST;
 153     };
 154
 155     class debug : public __sockopt_crtp<debug, bool>
 156     {
 157     public:
 158       friend __sockopt_crtp<debug, bool>;
 159       using __sockopt_crtp::__sockopt_crtp;
 160       using __sockopt_crtp::operator=;
 161
 162     private:
 163       static const int _S_level = SOL_SOCKET;
 164       static const int _S_name = SO_DEBUG;
 165     };
 166
 167     class do_not_route : public __sockopt_crtp<do_not_route, bool>
 168     {
 169     public:
 170       using __sockopt_crtp::__sockopt_crtp;
 171       using __sockopt_crtp::operator=;
 172
 173     private:
 174       friend __sockopt_crtp<do_not_route, bool>;
 175       static const int _S_level = SOL_SOCKET;
 176       static const int _S_name = SO_DONTROUTE;
 177     };
 178
 179     class keep_alive : public __sockopt_crtp<keep_alive, bool>
 180     {
 181     public:
 182       using __sockopt_crtp::__sockopt_crtp;
 183       using __sockopt_crtp::operator=;
 184
 185     private:
 186       friend __sockopt_crtp<keep_alive, bool>;
 187       static const int _S_level = SOL_SOCKET;
 188       static const int _S_name = SO_KEEPALIVE;
 189     };
 190
 191     class linger : public __sockopt_crtp<linger, ::linger>
 192     {
 193     public:
 194       using __sockopt_crtp::__sockopt_crtp;
 195       using __sockopt_crtp::operator=;
 196
 197       linger() noexcept = default;
 198
 199       linger(bool __e, chrono::seconds __t) noexcept
 200       {
 201         enabled(__e);
 202         timeout(__t);
 203       }
 204
 205       bool
 206       enabled() const noexcept
 207       { return _M_value.l_onoff != 0; }
 208
 209       void
 210       enabled(bool __e) noexcept
 211       { _M_value.l_onoff = int(__e); }
 212
 213       chrono::seconds
 214       timeout() const noexcept
 215       { return chrono::seconds(_M_value.l_linger); }
 216
 217       void
 218       timeout(chrono::seconds __t) noexcept
 219       { _M_value.l_linger = __t.count(); }
 220
 221     private:
 222       friend __sockopt_crtp<linger, ::linger>;
 223       static const int _S_level = SOL_SOCKET;
 224       static const int _S_name = SO_LINGER;
 225     };
 226
 227     class out_of_band_inline : public __sockopt_crtp<out_of_band_inline, bool>
 228     {
 229     public:
 230       using __sockopt_crtp::__sockopt_crtp;
 231       using __sockopt_crtp::operator=;
 232
 233     private:
 234       friend __sockopt_crtp<out_of_band_inline, bool>;
 235       static const int _S_level = SOL_SOCKET;
 236       static const int _S_name = SO_OOBINLINE;
 237     };
 238
 239     class receive_buffer_size : public __sockopt_crtp<receive_buffer_size>
 240     {
 241     public:
 242       using __sockopt_crtp::__sockopt_crtp;
 243       using __sockopt_crtp::operator=;
 244
 245     private:
 246       friend __sockopt_crtp<receive_buffer_size>;
 247       static const int _S_level = SOL_SOCKET;
 248       static const int _S_name = SO_RCVBUF;
 249     };
 250
 251     class receive_low_watermark : public __sockopt_crtp<receive_low_watermark>
 252     {
 253     public:
 254       using __sockopt_crtp::__sockopt_crtp;
 255       using __sockopt_crtp::operator=;
 256
 257     private:
 258       friend __sockopt_crtp<receive_low_watermark>;
 259       static const int _S_level = SOL_SOCKET;
 260       static const int _S_name = SO_RCVLOWAT;
 261     };
 262
 263     class reuse_address : public __sockopt_crtp<reuse_address, bool>
 264     {
 265     public:
 266       using __sockopt_crtp::__sockopt_crtp;
 267       using __sockopt_crtp::operator=;
 268
 269     private:
 270       friend __sockopt_crtp<reuse_address, bool>;
 271       static const int _S_level = SOL_SOCKET;
 272       static const int _S_name = SO_REUSEADDR;
 273     };
 274
 275     class send_buffer_size : public __sockopt_crtp<send_buffer_size>
 276     {
 277     public:
 278       using __sockopt_crtp::__sockopt_crtp;
 279       using __sockopt_crtp::operator=;
 280
 281     private:
 282       friend __sockopt_crtp<send_buffer_size>;
 283       static const int _S_level = SOL_SOCKET;
 284       static const int _S_name = SO_SNDBUF;
 285     };
 286
 287     class send_low_watermark : public __sockopt_crtp<send_low_watermark>
 288     {
 289     public:
 290       using __sockopt_crtp::__sockopt_crtp;
 291       using __sockopt_crtp::operator=;
 292
 293     private:
 294       friend __sockopt_crtp<send_low_watermark>;
 295       static const int _S_level = SOL_SOCKET;
 296       static const int _S_name = SO_SNDLOWAT;
 297     };
 298 #endif // HAVE_SYS_SOCKET_H
 299
 300     enum shutdown_type : int { };
 301 #if defined SHUT_RD && defined SHUT_WR && defined SHUT_RDWR
 302     static constexpr shutdown_type shutdown_receive = (shutdown_type)SHUT_RD;
 303     static constexpr shutdown_type shutdown_send    = (shutdown_type)SHUT_WR;
 304     static constexpr shutdown_type shutdown_both    = (shutdown_type)SHUT_RDWR;
 305 #endif
 306
 307     enum wait_type : int { };
 308 #ifdef _GLIBCXX_HAVE_POLL_H
 309     static constexpr wait_type wait_read  = (wait_type)POLLIN;
 310     static constexpr wait_type wait_write = (wait_type)POLLOUT;
 311     static constexpr wait_type wait_error = (wait_type)POLLERR;
 312 #else
 313     static constexpr wait_type wait_read  = (wait_type)1;
 314     static constexpr wait_type wait_write = (wait_type)2;
 315     static constexpr wait_type wait_error = (wait_type)4;
 316 #endif
 317
 318     enum message_flags : int { };
 319 #if defined MSG_PEEK && defined MSG_OOB && defined MSG_DONTROUTE
 320     static constexpr message_flags message_peek
 321       = (message_flags)MSG_PEEK;
 322     static constexpr message_flags message_out_of_band
 323       = (message_flags)MSG_OOB;
 324     static constexpr message_flags message_do_not_route
 325       = (message_flags)MSG_DONTROUTE;
 326 #endif
 327
 328 #ifdef SOMAXCONN
 329     static constexpr int max_listen_connections = SOMAXCONN;
 330 #else
 331     static constexpr int max_listen_connections = 4;
 332 #endif
 333
 334     // message_flags bitmask operations are defined as hidden friends.
 335
 336     friend constexpr message_flags
 337     operator&(message_flags __f1, message_flags __f2) noexcept
 338     { return message_flags( int(__f1) & int(__f2) ); }
 339
 340     friend constexpr message_flags
 341     operator|(message_flags __f1, message_flags __f2) noexcept
 342     { return message_flags( int(__f1) | int(__f2) ); }
 343
 344     friend constexpr message_flags
 345     operator^(message_flags __f1, message_flags __f2) noexcept
 346     { return message_flags( int(__f1) ^ int(__f2) ); }
 347
 348     friend constexpr message_flags
 349     operator~(message_flags __f) noexcept
 350     { return message_flags( ~int(__f) ); }
 351
 352     friend constexpr message_flags&
 353     operator&=(message_flags& __f1, message_flags __f2) noexcept
 354     { return __f1 = (__f1 & __f2); }
 355
 356     friend constexpr message_flags&
 357     operator|=(message_flags& __f1, message_flags __f2) noexcept
 358     { return __f1 = (__f1 | __f2); }
 359
 360     friend constexpr message_flags&
 361     operator^=(message_flags& __f1, message_flags __f2) noexcept
 362     { return __f1 = (__f1 ^ __f2); }
 363
 364 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 365   protected:
 366     struct __msg_hdr : ::msghdr
 367     {
 368 #ifdef IOV_MAX
 369       using __iovec_array = array<::iovec, IOV_MAX>;
 370 #elif _GLIBCXX_HAVE_UNISTD_H
 371       struct __iovec_array
 372       {
 373         __iovec_array() : _M_ptr(new ::iovec[size()]) { }
 374
 375         ::iovec& operator[](size_t __n) noexcept { return _M_ptr[__n]; }
 376
 377         ::iovec* data() noexcept { return _M_ptr.get(); }
 378
 379         static size_t size()
 380         {
 381           static const size_t __iov_max = ::sysconf(_SC_IOV_MAX);
 382           return __iov_max;
 383         }
 384
 385       private:
 386         unique_ptr<::iovec[]> _M_ptr;
 387       };
 388 #else
 389       using __iovec_array = array<::iovec, 16>;
 390 #endif
 391
 392       __iovec_array _M_iov;
 393
 394       template<typename _BufferSequence>
 395         explicit
 396         __msg_hdr(const _BufferSequence& __buffers)
 397         : msghdr()
 398         {
 399           auto __buf = net::buffer_sequence_begin(__buffers);
 400           const auto __bufend = net::buffer_sequence_end(__buffers);
 401           size_t __len = 0;
 402           while (__buf != __bufend && __len != _M_iov.size())
 403             {
 404               _M_iov[__len].iov_base = (void*)__buf->data();
 405               _M_iov[__len].iov_len = __buf->size();
 406               ++__buf;
 407               ++__len;
 408             }
 409           this->msg_iovlen = __len;
 410           this->msg_iov = _M_iov.data();
 411         }
 412
 413       template<typename _BufferSequence, typename _Endpoint>
 414         __msg_hdr(const _BufferSequence& __buffers, const _Endpoint& __ep)
 415         : __msg_hdr(__buffers)
 416         {
 417           this->msg_name = __ep.data();
 418           this->msg_namelen = __ep.size();
 419         }
 420     };
 421 #endif
 422
 423   protected:
 424     socket_base() = default;
 425     ~socket_base() = default;
 426   };
 427
 428   // TODO define socket_base static constants in .so for C++14 mode
 429
 430 #if _GLIBCXX_HAVE_UNISTD_H
 431
 432   class __socket_impl
 433   {
 434   protected:
 435
 436     using executor_type = io_context::executor_type;
 437     using native_handle_type = int;
 438
 439     explicit
 440     __socket_impl(io_context& __ctx) : _M_ctx(std::addressof(__ctx)) { }
 441
 442     __socket_impl(__socket_impl&& __rhs)
 443     : _M_ctx(__rhs._M_ctx),
 444       _M_sockfd(std::__exchange(__rhs._M_sockfd, -1)),
 445       _M_bits(std::__exchange(__rhs._M_bits, {}))
 446     { }
 447
 448     __socket_impl&
 449     operator=(__socket_impl&& __rhs)
 450     {
 451       _M_ctx = __rhs._M_ctx;
 452       _M_sockfd = std::__exchange(__rhs._M_sockfd, -1);
 453       _M_bits = std::__exchange(__rhs._M_bits, {});
 454       return *this;
 455     }
 456
 457     ~__socket_impl() = default;
 458
 459     __socket_impl(const __socket_impl&) = delete;
 460     __socket_impl& operator=(const __socket_impl&) = delete;
 461
 462     executor_type get_executor() noexcept { return _M_ctx->get_executor(); }
 463
 464     native_handle_type native_handle() noexcept { return _M_sockfd; }
 465
 466     bool is_open() const noexcept { return _M_sockfd != -1; }
 467
 468     void
 469     close(error_code& __ec)
 470     {
 471       if (is_open())
 472         {
 473           cancel(__ec);
 474           if (!__ec)
 475             {
 476               if (::close(_M_sockfd) == -1)
 477                 __ec.assign(errno, generic_category());
 478               else
 479                 {
 480                   get_executor().context()._M_remove_fd(_M_sockfd);
 481                   _M_sockfd = -1;
 482                 }
 483             }
 484         }
 485     }
 486
 487     void cancel(error_code& __ec) { _M_ctx->cancel(_M_sockfd, __ec); }
 488
 489     void
 490     non_blocking(bool __mode, error_code&)
 491     { _M_bits.non_blocking = __mode; }
 492
 493     bool non_blocking() const { return _M_bits.non_blocking; }
 494
 495     void
 496     native_non_blocking([[maybe_unused]] bool __mode, error_code& __ec)
 497     {
 498 #if defined _GLIBCXX_HAVE_FCNTL_H && defined _GLIBCXX_HAVE_DECL_O_NONBLOCK
 499       int __flags = ::fcntl(_M_sockfd, F_GETFL, 0);
 500       if (__flags >= 0)
 501         {
 502           if (__mode)
 503             __flags |= O_NONBLOCK;
 504           else
 505             __flags &= ~O_NONBLOCK;
 506           __flags = ::fcntl(_M_sockfd, F_SETFL, __flags);
 507         }
 508       if (__flags == -1)
 509         __ec.assign(errno, generic_category());
 510       else
 511         {
 512           __ec.clear();
 513           _M_bits.native_non_blocking = __mode;
 514         }
 515 #else
 516       __ec = std::make_error_code(std::errc::not_supported);
 517 #endif
 518     }
 519
 520     bool
 521     native_non_blocking() const
 522     {
 523 #if defined _GLIBCXX_HAVE_FCNTL_H && defined _GLIBCXX_HAVE_DECL_O_NONBLOCK
 524       if (_M_bits.native_non_blocking == -1)
 525         {
 526           const int __flags = ::fcntl(_M_sockfd, F_GETFL, 0);
 527           if (__flags == -1)
 528             return 0;
 529           _M_bits.native_non_blocking = __flags & O_NONBLOCK;
 530         }
 531       return _M_bits.native_non_blocking;
 532 #else
 533       return false;
 534 #endif
 535     }
 536
 537     io_context* _M_ctx;
 538     int         _M_sockfd{-1};
 539     struct {
 540       unsigned          non_blocking : 1;
 541       mutable signed    native_non_blocking : 2;
 542       unsigned          enable_connection_aborted : 1;
 543     } _M_bits{};
 544   };
 545
 546   template<typename _Protocol>
 547     class __basic_socket_impl : public __socket_impl
 548     {
 549       using __base = __socket_impl;
 550
 551     protected:
 552       using protocol_type = _Protocol;
 553       using endpoint_type = typename protocol_type::endpoint;
 554
 555       explicit
 556       __basic_socket_impl(io_context& __ctx) : __base(__ctx) { }
 557
 558       __basic_socket_impl(__basic_socket_impl&&) = default;
 559
 560       template<typename _OtherProtocol>
 561         __basic_socket_impl(__basic_socket_impl<_OtherProtocol>&& __rhs)
 562         : __base(std::move(__rhs)), _M_protocol(std::move(__rhs._M_protocol))
 563         { }
 564
 565       __basic_socket_impl&
 566       operator=(__basic_socket_impl&& __rhs)
 567       {
 568         if (this == std::addressof(__rhs))
 569           return *this;
 570         _M_close();
 571         __base::operator=(std::move(__rhs));
 572         return *this;
 573       }
 574
 575       ~__basic_socket_impl() { _M_close(); }
 576
 577       __basic_socket_impl(const __basic_socket_impl&) = delete;
 578       __basic_socket_impl& operator=(const __basic_socket_impl&) = delete;
 579
 580       void
 581       open(const protocol_type& __protocol, error_code& __ec)
 582       {
 583 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 584         if (is_open())
 585           __ec = socket_errc::already_open;
 586         else
 587           {
 588             _M_protocol = __protocol;
 589             _M_sockfd = ::socket(__protocol.family(), __protocol.type(),
 590                                  __protocol.protocol());
 591             if (is_open())
 592               {
 593                 get_executor().context()._M_add_fd(_M_sockfd);
 594               __ec.clear();
 595               }
 596             else
 597               __ec.assign(errno, std::generic_category());
 598           }
 599 #else
 600         __ec = std::make_error_code(errc::operation_not_supported);
 601 #endif
 602       }
 603
 604       void
 605       assign(const protocol_type& __protocol,
 606              const native_handle_type& __native_socket,
 607              error_code& __ec)
 608       {
 609         if (is_open())
 610           __ec = socket_errc::already_open;
 611         else
 612           {
 613             _M_protocol = __protocol;
 614             _M_bits.native_non_blocking = -1;
 615             _M_sockfd = __native_socket;
 616             if (is_open())
 617               {
 618                 get_executor().context()._M_add_fd(_M_sockfd);
 619                 __ec.clear();
 620               }
 621             else
 622               __ec.assign(errno, std::generic_category());
 623           }
 624       }
 625
 626       native_handle_type release(error_code& __ec)
 627       {
 628         __glibcxx_assert(is_open());
 629         cancel(__ec);
 630         return std::__exchange(_M_sockfd, -1);
 631       }
 632
 633       template<typename _SettableSocketOption>
 634         void
 635         set_option(const _SettableSocketOption& __option, error_code& __ec)
 636         {
 637 # ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 638           int __result = ::setsockopt(_M_sockfd, __option.level(_M_protocol),
 639                                       __option.name(_M_protocol),
 640                                       __option.data(_M_protocol),
 641                                       __option.size(_M_protocol));
 642           if (__result == -1)
 643             __ec.assign(errno, generic_category());
 644           else
 645             __ec.clear();
 646 #else
 647           __ec = std::make_error_code(std::errc::not_supported);
 648 #endif
 649         }
 650
 651       template<typename _GettableSocketOption>
 652         void
 653         get_option(_GettableSocketOption& __option, error_code& __ec) const
 654         {
 655 # ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 656           int __result = ::getsockopt(_M_sockfd, __option.level(_M_protocol),
 657                                       __option.name(_M_protocol),
 658                                       __option.data(_M_protocol),
 659                                       __option.size(_M_protocol));
 660           if (__result == -1)
 661             __ec.assign(errno, generic_category());
 662           else
 663             __ec.clear();
 664 #else
 665           __ec = std::make_error_code(std::errc::not_supported);
 666 #endif
 667         }
 668
 669       template<typename _IoControlCommand>
 670         void
 671         io_control(_IoControlCommand& __command, error_code& __ec)
 672         {
 673 #ifdef _GLIBCXX_HAVE_SYS_IOCTL_H
 674           int __result = ::ioctl(_M_sockfd, __command.name(),
 675                                  __command.data());
 676           if (__result == -1)
 677             __ec.assign(errno, generic_category());
 678           else
 679             __ec.clear();
 680 #else
 681           __ec = std::make_error_code(std::errc::not_supported);
 682 #endif
 683         }
 684
 685       endpoint_type
 686       local_endpoint(error_code& __ec) const
 687       {
 688         endpoint_type __endpoint;
 689 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 690         socklen_t __endpoint_len = __endpoint.capacity();
 691         if (::getsockname(_M_sockfd, (sockaddr*)__endpoint.data(),
 692                           &__endpoint_len) == -1)
 693           {
 694             __ec.assign(errno, generic_category());
 695             return endpoint_type{};
 696           }
 697         __ec.clear();
 698         __endpoint.resize(__endpoint_len);
 699 #else
 700         __ec = std::make_error_code(errc::operation_not_supported);
 701 #endif
 702         return __endpoint;
 703       }
 704
 705       void
 706       bind(const endpoint_type& __endpoint, error_code& __ec)
 707       {
 708 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 709         if (::bind(_M_sockfd, (sockaddr*)__endpoint.data(), __endpoint.size())
 710             == -1)
 711           __ec.assign(errno, generic_category());
 712         else
 713           __ec.clear();
 714 #else
 715         __ec = std::make_error_code(errc::operation_not_supported);
 716 #endif
 717       }
 718
 719       _Protocol _M_protocol{ endpoint_type{}.protocol() };
 720
 721     private:
 722       void
 723       _M_close()
 724       {
 725         if (is_open())
 726           {
 727             error_code __ec;
 728             cancel(__ec);
 729 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 730             set_option(socket_base::linger{false, chrono::seconds{}}, __ec);
 731 #endif
 732             ::close(_M_sockfd);
 733           }
 734       }
 735     };
 736
 737   template<typename _Protocol>
 738     class basic_socket
 739     : public socket_base, private __basic_socket_impl<_Protocol>
 740     {
 741       using __base = __basic_socket_impl<_Protocol>;
 742
 743     public:
 744       // types:
 745
 746       using executor_type = io_context::executor_type;
 747       using native_handle_type = int;
 748       using protocol_type = _Protocol;
 749       using endpoint_type = typename protocol_type::endpoint;
 750
 751       static_assert(__detail::__protocol<protocol_type>,
 752                     "protocol_type meets the Protocol requirements");
 753
 754       // basic_socket operations:
 755
 756       executor_type get_executor() noexcept { return __base::get_executor(); }
 757
 758       native_handle_type
 759       native_handle() noexcept { return __base::native_handle(); }
 760
 761       void
 762       open(const protocol_type& __protocol = protocol_type())
 763       { open(__protocol, __throw_on_error{"basic_socket::open"}); }
 764
 765       void
 766       open(const protocol_type& __protocol, error_code& __ec)
 767       { __base::open(__protocol, __ec); }
 768
 769       void
 770       assign(const protocol_type& __protocol,
 771              const native_handle_type& __native_socket)
 772       {
 773         assign(__protocol, __native_socket,
 774                __throw_on_error{"basic_socket::assign"});
 775       }
 776
 777       void
 778       assign(const protocol_type& __protocol,
 779              const native_handle_type& __native_socket,
 780              error_code& __ec)
 781       { __base::assign(__protocol, __native_socket, __ec); }
 782
 783       native_handle_type release()
 784       { return release(__throw_on_error{"basic_socket::release"}); }
 785
 786       native_handle_type release(error_code& __ec)
 787       { return __base::release(__ec); }
 788
 789       _GLIBCXX_NODISCARD bool
 790       is_open() const noexcept { return __base::is_open(); }
 791
 792       void close() { close(__throw_on_error{"basic_socket::close"}); }
 793
 794       void close(error_code& __ec) { __base::close(__ec); }
 795
 796       void cancel() { cancel(__throw_on_error{"basic_socket::cancel"}); }
 797
 798       void cancel(error_code& __ec) { __base::cancel(__ec); }
 799
 800       template<typename _SettableSocketOption>
 801         void
 802         set_option(const _SettableSocketOption& __option)
 803         { set_option(__option, __throw_on_error{"basic_socket::set_option"}); }
 804
 805       template<typename _SettableSocketOption>
 806         void
 807         set_option(const _SettableSocketOption& __option, error_code& __ec)
 808         { __base::set_option(__option, __ec); }
 809
 810       template<typename _GettableSocketOption>
 811         void
 812         get_option(_GettableSocketOption& __option) const
 813         { get_option(__option, __throw_on_error{"basic_socket::get_option"}); }
 814
 815       template<typename _GettableSocketOption>
 816         void
 817         get_option(_GettableSocketOption& __option, error_code& __ec) const
 818         { __base::get_option(__option, __ec); }
 819
 820       template<typename _IoControlCommand>
 821         void
 822         io_control(_IoControlCommand& __command)
 823         {
 824           io_control(__command, __throw_on_error{"basic_socket::io_control"});
 825         }
 826
 827       template<typename _IoControlCommand>
 828         void
 829         io_control(_IoControlCommand& __command, error_code& __ec)
 830         { __base::io_control(__command, __ec); }
 831
 832       void
 833       non_blocking(bool __mode)
 834       { non_blocking(__mode, __throw_on_error{"basic_socket::non_blocking"}); }
 835
 836       void
 837       non_blocking(bool __mode, error_code& __ec)
 838       { __base::non_blocking(__mode, __ec); }
 839
 840       bool non_blocking() const { return __base::non_blocking(); }
 841
 842       void
 843       native_non_blocking(bool __mode)
 844       {
 845         native_non_blocking(__mode, __throw_on_error{
 846             "basic_socket::native_non_blocking"});
 847       }
 848
 849       void
 850       native_non_blocking(bool __mode, error_code& __ec)
 851       { __base::native_non_blocking(__mode, __ec); }
 852
 853       bool
 854       native_non_blocking() const
 855       { return __base::native_non_blocking(); }
 856
 857       bool at_mark() const
 858       { return at_mark(__throw_on_error{"basic_socket::at_mark"}); }
 859
 860       bool
 861       at_mark(error_code& __ec) const
 862       {
 863 #ifdef _GLIBCXX_HAVE_SOCKATMARK
 864         const int __result = ::sockatmark(native_handle());
 865         if (__result == -1)
 866           {
 867             __ec.assign(errno, generic_category());
 868             return false;
 869           }
 870         __ec.clear();
 871         return (bool)__result;
 872 #else
 873         __ec = std::make_error_code(errc::operation_not_supported);
 874         return false;
 875 #endif
 876       }
 877
 878       size_t
 879       available() const
 880       { return available(__throw_on_error{"basic_socket::available"}); }
 881
 882       size_t
 883       available(error_code& __ec) const
 884       {
 885         if (!is_open())
 886           {
 887             __ec = std::make_error_code(errc::bad_file_descriptor);
 888             return 0;
 889           }
 890 #if defined _GLIBCXX_HAVE_SYS_IOCTL_H && defined FIONREAD
 891         int __avail = 0;
 892         if (::ioctl(this->_M_sockfd, FIONREAD, &__avail) == -1)
 893           {
 894             __ec.assign(errno, generic_category());
 895             return 0;
 896           }
 897         __ec.clear();
 898         return __avail;
 899 #else
 900         return 0;
 901 #endif
 902       }
 903
 904       void
 905       bind(const endpoint_type& __endpoint)
 906       { return bind(__endpoint, __throw_on_error{"basic_socket::bind"}); }
 907
 908       void
 909       bind(const endpoint_type& __endpoint, error_code& __ec)
 910       { __base::bind(__endpoint, __ec); }
 911
 912       void shutdown(shutdown_type __what)
 913       { return shutdown(__what, __throw_on_error{"basic_socket::shutdown"}); }
 914
 915       void
 916       shutdown(shutdown_type __what, error_code& __ec)
 917       {
 918 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 919         if (::shutdown(native_handle(), static_cast<int>(__what)) == -1)
 920           __ec.assign(errno, generic_category());
 921         else
 922           __ec.clear();
 923 #else
 924         __ec = std::make_error_code(errc::operation_not_supported);
 925 #endif
 926       }
 927
 928       endpoint_type
 929       local_endpoint() const
 930       {
 931         return local_endpoint(
 932             __throw_on_error{"basic_socket::local_endpoint"});
 933       }
 934
 935       endpoint_type
 936       local_endpoint(error_code& __ec) const
 937       { return __base::local_endpoint(__ec); }
 938
 939       endpoint_type
 940       remote_endpoint() const
 941       {
 942         return remote_endpoint(
 943             __throw_on_error{"basic_socket::remote_endpoint"});
 944       }
 945
 946       endpoint_type
 947       remote_endpoint(error_code& __ec) const
 948       {
 949         endpoint_type __endpoint;
 950 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 951         socklen_t __endpoint_len = __endpoint.capacity();
 952         if (::getpeername(this->_M_sockfd, (sockaddr*)__endpoint.data(),
 953                           &__endpoint_len)
 954             == -1)
 955           {
 956             __ec.assign(errno, generic_category());
 957             return endpoint_type{};
 958           }
 959         __ec.clear();
 960         __endpoint.resize(__endpoint_len);
 961 #else
 962         __ec = std::make_error_code(errc::operation_not_supported);
 963 #endif
 964         return __endpoint;
 965       }
 966
 967       void
 968       connect(const endpoint_type& __endpoint)
 969       {
 970         return connect(__endpoint, __throw_on_error{"basic_socket::connect"});
 971       }
 972
 973       void
 974       connect(const endpoint_type& __endpoint, error_code& __ec)
 975       {
 976 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
 977         if (!is_open())
 978           {
 979             open(__endpoint.protocol(), __ec);
 980             if (__ec)
 981               return;
 982           }
 983         if (::connect(native_handle(), (const sockaddr*)__endpoint.data(),
 984                       __endpoint.size()) == -1)
 985           __ec.assign(errno, generic_category());
 986         else
 987           __ec.clear();
 988 #else
 989         __ec = std::make_error_code(errc::operation_not_supported);
 990 #endif
 991       }
 992
 993       template<typename _CompletionToken>
 994         __deduced_t<_CompletionToken, void(error_code)>
 995         async_connect(const endpoint_type& __endpoint,
 996                       _CompletionToken&& __token)
 997         {
 998           async_completion<_CompletionToken, void(error_code)> __init{__token};
 999
1000           if (!is_open())
1001             {
1002               error_code __ec;
1003               open(__endpoint.protocol(), __ec);
1004               if (__ec)
1005                 {
1006                   auto __ex = net::get_associated_executor(
1007                       __init.completion_handler, get_executor());
1008                   auto __a = get_associated_allocator(
1009                       __init.completion_handler, std::allocator<void>());
1010                   __ex.post(
1011                       [__h = std::move(__init.completion_handler), __ec]
1012                       () mutable
1013                       { __h(__ec); }, __a);
1014                   return __init.result.get();
1015                 }
1016             }
1017
1018           get_executor().context().async_wait( native_handle(),
1019               (int) socket_base::wait_read,
1020               [__h = std::move(__init.completion_handler),
1021                __ep = std::move(__endpoint),
1022                __fd = native_handle()]
1023                (error_code __ec) mutable {
1024 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1025                   if (!__ec && ::connect(__fd, (const sockaddr*)__ep.data(),
1026                                          __ep.size()) == -1)
1027                     __ec.assign(errno, generic_category());
1028 #else
1029                   __ec = std::make_error_code(errc::operation_not_supported);
1030 #endif
1031                   __h(__ec);
1032               });
1033           return __init.result.get();
1034         }
1035
1036       void
1037       wait(wait_type __w)
1038       { return wait(__w, __throw_on_error{"basic_socket::wait"}); }
1039
1040       void
1041       wait(wait_type __w, error_code& __ec)
1042       {
1043 #ifdef _GLIBCXX_HAVE_POLL_H
1044         ::pollfd __fd;
1045         __fd.fd = native_handle();
1046         __fd.events = static_cast<int>(__w);
1047         int __res = ::poll(&__fd, 1, -1);
1048         if (__res == -1)
1049           __ec.assign(errno, generic_category());
1050         else
1051           __ec.clear();
1052 #else
1053         __ec = std::make_error_code(errc::operation_not_supported);
1054 #endif
1055       }
1056
1057       template<typename _CompletionToken>
1058         __deduced_t<_CompletionToken, void(error_code)>
1059         async_wait(wait_type __w, _CompletionToken&& __token)
1060         {
1061           async_completion<_CompletionToken, void(error_code)> __init{__token};
1062           get_executor().context().async_wait( native_handle(),
1063               static_cast<int>(__w),
1064               [__h = std::move(__init.completion_handler)]
1065               (error_code __ec) mutable {
1066                   __h(__ec);
1067               });
1068           return __init.result.get();
1069         }
1070
1071     protected:
1072       // construct / copy / destroy:
1073
1074       using __base::__base;
1075
1076       explicit
1077       basic_socket(io_context& __ctx) : __base(__ctx) { }
1078
1079       basic_socket(io_context& __ctx, const protocol_type& __protocol)
1080       : __base(__ctx)
1081       { open(__protocol); }
1082
1083       basic_socket(io_context& __ctx, const endpoint_type& __endpoint)
1084       : basic_socket(__ctx, __endpoint.protocol())
1085       { bind(__endpoint); }
1086
1087       basic_socket(io_context& __ctx, const protocol_type& __protocol,
1088                    const native_handle_type& __native_socket)
1089       : __base(__ctx)
1090       { assign(__protocol, __native_socket); }
1091
1092       basic_socket(const basic_socket&) = delete;
1093
1094       basic_socket(basic_socket&& __rhs) = default;
1095
1096       template<typename _OtherProtocol, typename _Requires
1097                = _Require<is_convertible<_OtherProtocol, _Protocol>>>
1098         basic_socket(basic_socket<_OtherProtocol>&& __rhs)
1099         : __base(std::move(__rhs)) { }
1100
1101       ~basic_socket() = default;
1102
1103       basic_socket& operator=(const basic_socket&) = delete;
1104
1105       basic_socket& operator=(basic_socket&& __rhs) = default;
1106
1107       template<typename _OtherProtocol>
1108         enable_if_t<is_convertible<_OtherProtocol, _Protocol>::value,
1109                     basic_socket&>
1110         operator=(basic_socket<_OtherProtocol>&& __rhs)
1111         { return *this = basic_socket{std::move(__rhs)}; }
1112     };
1113
1114   template<typename _Protocol>
1115     class basic_datagram_socket : public basic_socket<_Protocol>
1116     {
1117       using __base = basic_socket<_Protocol>;
1118
1119     public:
1120       // types:
1121
1122       using native_handle_type = int;
1123       using protocol_type = _Protocol;
1124       using endpoint_type = typename protocol_type::endpoint;
1125
1126       // construct / copy / destroy:
1127
1128       explicit
1129       basic_datagram_socket(io_context& __ctx) : __base(__ctx) { }
1130
1131       basic_datagram_socket(io_context& __ctx, const protocol_type& __protocol)
1132       : __base(__ctx, __protocol) { }
1133
1134       basic_datagram_socket(io_context& __ctx, const endpoint_type& __endpoint)
1135       : __base(__ctx, __endpoint) { }
1136
1137       basic_datagram_socket(io_context& __ctx, const protocol_type& __protocol,
1138                             const native_handle_type& __native_socket)
1139       : __base(__ctx, __protocol, __native_socket) { }
1140
1141       basic_datagram_socket(const basic_datagram_socket&) = delete;
1142
1143       basic_datagram_socket(basic_datagram_socket&& __rhs) = default;
1144
1145       template<typename _OtherProtocol, typename _Requires
1146                = _Require<is_convertible<_OtherProtocol, _Protocol>>>
1147         basic_datagram_socket(basic_datagram_socket<_OtherProtocol>&& __rhs)
1148         : __base(std::move(__rhs)) { }
1149
1150       ~basic_datagram_socket() = default;
1151
1152       basic_datagram_socket& operator=(const basic_datagram_socket&) = delete;
1153
1154       basic_datagram_socket& operator=(basic_datagram_socket&& __rhs) = default;
1155
1156       template<typename _OtherProtocol>
1157         enable_if_t<is_convertible<_OtherProtocol, _Protocol>::value,
1158                     basic_datagram_socket&>
1159         operator=(basic_datagram_socket<_OtherProtocol>&& __rhs)
1160         {
1161           __base::operator=(std::move(__rhs));
1162           return *this;
1163         }
1164
1165       // basic_datagram_socket operations:
1166
1167       template<typename _MutableBufferSequence>
1168         size_t
1169         receive(const _MutableBufferSequence& __buffers)
1170         {
1171           return receive(__buffers, socket_base::message_flags(),
1172                          __throw_on_error{"basic_datagram_socket::receive"});
1173         }
1174
1175       template<typename _MutableBufferSequence>
1176         size_t
1177         receive(const _MutableBufferSequence& __buffers, error_code& __ec)
1178         { return receive(__buffers, socket_base::message_flags(), __ec); }
1179
1180       template<typename _MutableBufferSequence>
1181         size_t
1182         receive(const _MutableBufferSequence& __buffers,
1183                        socket_base::message_flags __flags)
1184         {
1185           return receive(__buffers, __flags,
1186                          __throw_on_error{"basic_datagram_socket::receive"});
1187         }
1188
1189       template<typename _MutableBufferSequence>
1190         size_t
1191         receive(const _MutableBufferSequence& __buffers,
1192                 socket_base::message_flags __flags, error_code& __ec)
1193         {
1194 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1195           socket_base::__msg_hdr __msg(__buffers);
1196           ssize_t __result = ::recvmsg(this->native_handle(), &__msg,
1197                                        static_cast<int>(__flags));
1198           if (__result == -1)
1199             {
1200               __ec.assign(errno, generic_category());
1201               return 0;
1202             }
1203           __ec.clear();
1204           return __result;
1205 #else
1206           __ec = std::make_error_code(errc::operation_not_supported);
1207           return 0;
1208 #endif
1209         }
1210
1211       template<typename _MutableBufferSequence, typename _CompletionToken>
1212         __deduced_t<_CompletionToken, void(error_code, size_t)>
1213         async_receive(const _MutableBufferSequence& __buffers,
1214                       _CompletionToken&& __token)
1215         {
1216           return async_receive(__buffers, socket_base::message_flags(),
1217                                std::forward<_CompletionToken>(__token));
1218         }
1219
1220       template<typename _MutableBufferSequence, typename _CompletionToken>
1221         __deduced_t<_CompletionToken, void(error_code, size_t)>
1222         async_receive(const _MutableBufferSequence& __buffers,
1223                       socket_base::message_flags __flags,
1224                       _CompletionToken&& __token)
1225         {
1226           async_completion<_CompletionToken, void(error_code, size_t)>
1227             __init{__token};
1228
1229           this->get_executor().context().async_wait(this->native_handle(),
1230               (int) socket_base::wait_read,
1231               [__h = std::move(__init.completion_handler),
1232                &__buffers, __flags = static_cast<int>(__flags),
1233                __fd = this->native_handle()]
1234               (error_code __ec) mutable {
1235                   if (__ec)
1236                     {
1237                       __h(__ec);
1238                       return;
1239                     }
1240 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1241                   socket_base::__msg_hdr __msg(__buffers);
1242                   ssize_t __result = ::recvmsg(__fd, &__msg, __flags);
1243                   if (__result == -1)
1244                     {
1245                       __ec.assign(errno, generic_category());
1246                       __result = 0;
1247                     }
1248                   else
1249                     __ec.clear();
1250                   __h(__ec, __result);
1251 #else
1252                   __h(std::make_error_code(errc::operation_not_supported), 0);
1253 #endif
1254               });
1255           return __init.result.get();
1256         }
1257
1258       template<typename _MutableBufferSequence>
1259         size_t
1260         receive_from(const _MutableBufferSequence& __buffers,
1261                      endpoint_type& __sender)
1262         {
1263           return receive_from(__buffers, __sender,
1264                               socket_base::message_flags(),
1265                               __throw_on_error{
1266                                   "basic_datagram_socket::receive_from"});
1267         }
1268
1269       template<typename _MutableBufferSequence>
1270         size_t
1271         receive_from(const _MutableBufferSequence& __buffers,
1272                      endpoint_type& __sender, error_code& __ec)
1273         {
1274           return receive_from(__buffers, __sender,
1275                               socket_base::message_flags(), __ec);
1276         }
1277
1278       template<typename _MutableBufferSequence>
1279         size_t
1280         receive_from(const _MutableBufferSequence& __buffers,
1281                      endpoint_type& __sender,
1282                      socket_base::message_flags __flags)
1283         {
1284           return receive_from(__buffers, __sender, __flags,
1285                               __throw_on_error{
1286                                   "basic_datagram_socket::receive_from"});
1287         }
1288
1289       template<typename _MutableBufferSequence>
1290         size_t
1291         receive_from(const _MutableBufferSequence& __buffers,
1292                      endpoint_type& __sender,
1293                      socket_base::message_flags __flags,
1294                      error_code& __ec)
1295         {
1296 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1297           socket_base::__msg_hdr __msg(__buffers, __sender);
1298           ssize_t __result = ::recvmsg(this->native_handle(), &__msg,
1299                                        static_cast<int>(__flags));
1300           if (__result == -1)
1301             {
1302               __ec.assign(errno, generic_category());
1303               return 0;
1304             }
1305           __ec.clear();
1306           __sender.resize(__msg.msg_namelen);
1307           return __result;
1308 #else
1309           __ec = std::make_error_code(errc::operation_not_supported);
1310           return 0;
1311 #endif
1312         }
1313
1314       template<typename _MutableBufferSequence, typename _CompletionToken>
1315         __deduced_t<_CompletionToken, void(error_code, size_t)>
1316         async_receive_from(const _MutableBufferSequence& __buffers,
1317                            endpoint_type& __sender,
1318                            _CompletionToken&& __token)
1319         {
1320           return async_receive_from(__buffers, __sender,
1321                                     socket_base::message_flags(),
1322                                     std::forward<_CompletionToken>(__token));
1323         }
1324
1325       template<typename _MutableBufferSequence, typename _CompletionToken>
1326         __deduced_t<_CompletionToken, void(error_code, size_t)>
1327         async_receive_from(const _MutableBufferSequence& __buffers,
1328                            endpoint_type& __sender,
1329                            socket_base::message_flags __flags,
1330                            _CompletionToken&& __token)
1331         {
1332           async_completion<_CompletionToken, void(error_code, size_t)>
1333             __init{__token};
1334
1335           this->get_executor().context().async_wait( this->native_handle(),
1336               (int) socket_base::wait_read,
1337               [__h = std::move(__init.completion_handler),
1338                &__buffers, __flags = static_cast<int>(__flags),
1339                __sender = std::move(__sender),
1340                __fd = this->native_handle()]
1341               (error_code __ec) mutable {
1342                   if (__ec)
1343                     {
1344                       __h(__ec);
1345                       return;
1346                     }
1347 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1348                   socket_base::__msg_hdr __msg(__buffers, __sender);
1349                   ssize_t __result = ::recvmsg(__fd, &__msg, __flags);
1350                   if (__result == -1)
1351                     {
1352                       __ec.assign(errno, generic_category());
1353                       __result = 0;
1354                     }
1355                   else
1356                     {
1357                       __ec.clear();
1358                       __sender.resize(__msg.msg_namelen);
1359                     }
1360                   __h(__ec, __result);
1361 #else
1362                   __h(std::make_error_code(errc::operation_not_supported), 0);
1363 #endif
1364               });
1365           return __init.result.get();
1366         }
1367
1368       template<typename _ConstBufferSequence>
1369         size_t
1370         send(const _ConstBufferSequence& __buffers)
1371         {
1372           return send(__buffers, socket_base::message_flags(),
1373                       __throw_on_error{"basic_datagram_socket::send"});
1374         }
1375
1376       template<typename _ConstBufferSequence>
1377         size_t
1378         send(const _ConstBufferSequence& __buffers, error_code& __ec)
1379         { return send(__buffers, socket_base::message_flags(), __ec); }
1380
1381       template<typename _ConstBufferSequence>
1382         size_t
1383         send(const _ConstBufferSequence& __buffers,
1384              socket_base::message_flags __flags)
1385         {
1386           return send(__buffers, __flags,
1387                       __throw_on_error{"basic_datagram_socket::send"});
1388         }
1389
1390       template<typename _ConstBufferSequence>
1391         size_t
1392         send(const _ConstBufferSequence& __buffers,
1393              socket_base::message_flags __flags, error_code& __ec)
1394         {
1395 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1396           socket_base::__msg_hdr __msg(__buffers);
1397           ssize_t __result = ::sendmsg(this->native_handle(), &__msg,
1398                                        static_cast<int>(__flags));
1399           if (__result == -1)
1400             {
1401               __ec.assign(errno, generic_category());
1402               return 0;
1403             }
1404           __ec.clear();
1405           return __result;
1406 #else
1407           __ec = std::make_error_code(errc::operation_not_supported);
1408           return 0;
1409 #endif
1410         }
1411
1412       template<typename _ConstBufferSequence, typename _CompletionToken>
1413         __deduced_t<_CompletionToken, void(error_code, size_t)>
1414         async_send(const _ConstBufferSequence& __buffers,
1415                         _CompletionToken&& __token)
1416         {
1417           return async_send(__buffers, socket_base::message_flags(),
1418                             std::forward<_CompletionToken>(__token));
1419         }
1420
1421       template<typename _ConstBufferSequence, typename _CompletionToken>
1422         __deduced_t<_CompletionToken, void(error_code, size_t)>
1423         async_send(const _ConstBufferSequence& __buffers,
1424                    socket_base::message_flags __flags,
1425                    _CompletionToken&& __token)
1426         {
1427           async_completion<_CompletionToken, void(error_code, size_t)>
1428             __init{__token};
1429
1430           this->get_executor().context().async_wait( this->native_handle(),
1431               (int) socket_base::wait_write,
1432               [__h = std::move(__init.completion_handler),
1433                &__buffers, __flags = static_cast<int>(__flags),
1434                __fd = this->native_handle()]
1435               (error_code __ec) mutable {
1436                   if (__ec)
1437                     {
1438                       __h(__ec);
1439                       return;
1440                     }
1441 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1442                   socket_base::__msg_hdr __msg(__buffers);
1443                   ssize_t __result = ::sendmsg(__fd, &__msg, __flags);
1444                   if (__result == -1)
1445                     {
1446                       __ec.assign(errno, generic_category());
1447                       __result = 0;
1448                     }
1449                   else
1450                     __ec.clear();
1451                   __h(__ec, __result);
1452 #else
1453                   __h(std::make_error_code(errc::operation_not_supported), 0);
1454 #endif
1455               });
1456           return __init.result.get();
1457         }
1458
1459       template<typename _ConstBufferSequence>
1460         size_t
1461         send_to(const _ConstBufferSequence& __buffers,
1462                 const endpoint_type& __recipient)
1463         {
1464           return send_to(__buffers, __recipient,
1465                          socket_base::message_flags(),
1466                          __throw_on_error{"basic_datagram_socket::send_to"});
1467         }
1468
1469       template<typename _ConstBufferSequence>
1470         size_t
1471         send_to(const _ConstBufferSequence& __buffers,
1472                 const endpoint_type& __recipient, error_code& __ec)
1473         {
1474           return send_to(__buffers, __recipient,
1475                          socket_base::message_flags(), __ec);
1476         }
1477
1478       template<typename _ConstBufferSequence>
1479         size_t
1480         send_to(const _ConstBufferSequence& __buffers,
1481                 const endpoint_type& __recipient,
1482                 socket_base::message_flags __flags)
1483         {
1484           return send_to(__buffers, __recipient, __flags,
1485                          __throw_on_error{"basic_datagram_socket::send_to"});
1486         }
1487
1488       template<typename _ConstBufferSequence>
1489         size_t
1490         send_to(const _ConstBufferSequence& __buffers,
1491                 const endpoint_type& __recipient,
1492                 socket_base::message_flags __flags, error_code& __ec)
1493         {
1494 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1495           socket_base::__msg_hdr __msg(__buffers, __recipient);
1496           ssize_t __result = ::sendmsg(this->native_handle(), &__msg,
1497                                        static_cast<int>(__flags));
1498           if (__result == -1)
1499             {
1500               __ec.assign(errno, generic_category());
1501               return 0;
1502             }
1503           __ec.clear();
1504           __recipient.resize(__msg.msg_namelen);
1505           return __result;
1506 #else
1507           __ec = std::make_error_code(errc::operation_not_supported);
1508           return 0;
1509 #endif
1510         }
1511
1512       template<typename _ConstBufferSequence, typename _CompletionToken>
1513         __deduced_t<_CompletionToken, void(error_code, size_t)>
1514         async_send_to(const _ConstBufferSequence& __buffers,
1515                       const endpoint_type& __recipient,
1516                       _CompletionToken&& __token)
1517         {
1518           return async_send_to(__buffers, __recipient,
1519                                socket_base::message_flags(),
1520                                std::forward<_CompletionToken>(__token));
1521         }
1522
1523       template<typename _ConstBufferSequence, typename _CompletionToken>
1524         __deduced_t<_CompletionToken, void(error_code, size_t)>
1525         async_send_to(const _ConstBufferSequence& __buffers,
1526                       const endpoint_type& __recipient,
1527                       socket_base::message_flags __flags,
1528                       _CompletionToken&& __token)
1529         {
1530           async_completion<_CompletionToken, void(error_code, size_t)>
1531             __init{__token};
1532
1533           this->get_executor().context().async_wait( this->native_handle(),
1534               (int) socket_base::wait_write,
1535               [__h = std::move(__init.completion_handler),
1536                &__buffers, __flags = static_cast<int>(__flags),
1537                __recipient = std::move(__recipient),
1538                __fd = this->native_handle()]
1539               (error_code __ec) mutable {
1540                   if (__ec)
1541                     {
1542                       __h(__ec);
1543                       return;
1544                     }
1545 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1546                   socket_base::__msg_hdr __msg(__buffers, __recipient);
1547                   ssize_t __result = ::sendmsg(__fd, &__msg, __flags);
1548                   if (__result == -1)
1549                     {
1550                       __ec.assign(errno, generic_category());
1551                       __result = 0;
1552                     }
1553                   else
1554                     {
1555                       __ec.clear();
1556                       __recipient.resize(__msg.msg_namelen);
1557                     }
1558                   __h(__ec, __result);
1559 #else
1560                   __h(std::make_error_code(errc::operation_not_supported), 0);
1561 #endif
1562               });
1563           return __init.result.get();
1564         }
1565     };
1566
1567   template<typename _Protocol>
1568     class basic_stream_socket : public basic_socket<_Protocol>
1569     {
1570       using __base = basic_socket<_Protocol>;
1571
1572     public:
1573       // types:
1574
1575       using native_handle_type = int;
1576       using protocol_type = _Protocol;
1577       using endpoint_type = typename protocol_type::endpoint;
1578
1579       // construct / copy / destroy:
1580
1581       explicit
1582       basic_stream_socket(io_context& __ctx) : __base(__ctx) { }
1583
1584       basic_stream_socket(io_context& __ctx, const protocol_type& __protocol)
1585       : __base(__ctx, __protocol) { }
1586
1587       basic_stream_socket(io_context& __ctx, const endpoint_type& __endpoint)
1588       : __base(__ctx, __endpoint) { }
1589
1590       basic_stream_socket(io_context& __ctx, const protocol_type& __protocol,
1591                           const native_handle_type& __native_socket)
1592       : __base(__ctx, __protocol, __native_socket) { }
1593
1594       basic_stream_socket(const basic_stream_socket&) = delete;
1595
1596       basic_stream_socket(basic_stream_socket&& __rhs) = default;
1597
1598       template<typename _OtherProtocol, typename _Requires
1599                = _Require<is_convertible<_OtherProtocol, _Protocol>>>
1600         basic_stream_socket(basic_stream_socket<_OtherProtocol>&& __rhs)
1601         : __base(std::move(__rhs)) { }
1602
1603       ~basic_stream_socket() = default;
1604
1605       basic_stream_socket& operator=(const basic_stream_socket&) = delete;
1606
1607       basic_stream_socket& operator=(basic_stream_socket&& __rhs) = default;
1608
1609       template<class _OtherProtocol>
1610         enable_if_t<is_convertible<_OtherProtocol, _Protocol>::value,
1611                     basic_stream_socket&>
1612         operator=(basic_stream_socket<_OtherProtocol>&& __rhs)
1613         {
1614           __base::operator=(std::move(__rhs));
1615           return *this;
1616         }
1617
1618       // basic_stream_socket operations:
1619
1620       template<class _MutableBufferSequence>
1621         size_t
1622         receive(const _MutableBufferSequence& __buffers)
1623         {
1624           return receive(__buffers, socket_base::message_flags(),
1625                          __throw_on_error{"basic_stream_socket::receive"});
1626         }
1627
1628       template<class _MutableBufferSequence>
1629         size_t
1630         receive(const _MutableBufferSequence& __buffers, error_code& __ec)
1631         { return receive(__buffers, socket_base::message_flags(), __ec); }
1632
1633       template<class _MutableBufferSequence>
1634         size_t
1635         receive(const _MutableBufferSequence& __buffers,
1636                 socket_base::message_flags __flags)
1637         {
1638           return receive(__buffers, __flags,
1639                          __throw_on_error{"basic_stream_socket::receive"});
1640         }
1641
1642       template<class _MutableBufferSequence>
1643         size_t
1644         receive(const _MutableBufferSequence& __buffers,
1645                 socket_base::message_flags __flags, error_code& __ec)
1646         {
1647           if (__buffer_empty(__buffers))
1648             {
1649               __ec.clear();
1650               return 0;
1651             }
1652 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1653           socket_base::__msg_hdr __msg(__buffers);
1654           ssize_t __result = ::recvmsg(this->native_handle(), &__msg,
1655                                        static_cast<int>(__flags));
1656           if (__result >= 0)
1657             {
1658               __ec.clear();
1659               return __result;
1660             }
1661           __ec.assign(errno, generic_category());
1662 #else
1663           __ec = std::make_error_code(errc::operation_not_supported);
1664 #endif
1665           return 0;
1666         }
1667
1668       template<class _MutableBufferSequence, class _CompletionToken>
1669         __deduced_t<_CompletionToken, void(error_code, size_t)>
1670         async_receive(const _MutableBufferSequence& __buffers,
1671                       _CompletionToken&& __token)
1672         {
1673           return async_receive(__buffers, socket_base::message_flags(),
1674                                std::forward<_CompletionToken>(__token));
1675         }
1676
1677       template<class _MutableBufferSequence, class _CompletionToken>
1678         __deduced_t<_CompletionToken, void(error_code, size_t)>
1679         async_receive(const _MutableBufferSequence& __buffers,
1680                       socket_base::message_flags __flags,
1681                       _CompletionToken&& __token)
1682         {
1683           async_completion<_CompletionToken, void(error_code, size_t)>
1684             __init{__token};
1685
1686           if (__buffer_empty(__buffers))
1687             {
1688               auto __ex = net::get_associated_executor(
1689                   __init.completion_handler, this->get_executor());
1690               auto __a = get_associated_allocator(
1691                   __init.completion_handler, std::allocator<void>());
1692               __ex.post(
1693                   [__h=std::move(__init.completion_handler)] () mutable
1694                   { __h(error_code{}, 0); }, __a);
1695               return __init.result.get();
1696             }
1697
1698           this->get_executor().context().async_wait(this->native_handle(),
1699               (int) socket_base::wait_read,
1700               [__h = std::move(__init.completion_handler),
1701                &__buffers, __flags = static_cast<int>(__flags),
1702                __fd = this->native_handle()]
1703               (error_code __ec) mutable {
1704                   if (__ec)
1705                     {
1706                       __h(__ec);
1707                       return;
1708                     }
1709 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1710                   socket_base::__msg_hdr __msg(__buffers);
1711                   ssize_t __result = ::recvmsg(__fd, &__msg, __flags);
1712                   if (__result == -1)
1713                     {
1714                       __ec.assign(errno, generic_category());
1715                       __result = 0;
1716                     }
1717                   else
1718                     __ec.clear();
1719                   __h(__ec, __result);
1720 #else
1721                   __h(std::make_error_code(errc::operation_not_supported), 0);
1722 #endif
1723               });
1724           return __init.result.get();
1725         }
1726
1727       template<class _ConstBufferSequence>
1728         size_t
1729         send(const _ConstBufferSequence& __buffers)
1730         {
1731           return send(__buffers, socket_base::message_flags(),
1732                       __throw_on_error{"basic_stream_socket::send"});
1733         }
1734
1735       template<class _ConstBufferSequence>
1736         size_t
1737         send(const _ConstBufferSequence& __buffers, error_code& __ec)
1738         { return send(__buffers, socket_base::message_flags(), __ec); }
1739
1740       template<class _ConstBufferSequence>
1741         size_t
1742         send(const _ConstBufferSequence& __buffers,
1743              socket_base::message_flags __flags)
1744         {
1745           return send(__buffers, socket_base::message_flags(),
1746                       __throw_on_error{"basic_stream_socket::send"});
1747         }
1748
1749       template<class _ConstBufferSequence>
1750         size_t
1751         send(const _ConstBufferSequence& __buffers,
1752              socket_base::message_flags __flags, error_code& __ec)
1753         {
1754           if (__buffer_empty(__buffers))
1755             {
1756               __ec.clear();
1757               return 0;
1758             }
1759 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1760           socket_base::__msg_hdr __msg(__buffers);
1761           ssize_t __result = ::sendmsg(this->native_handle(), &__msg,
1762                                        static_cast<int>(__flags));
1763           if (__result >= 0)
1764             {
1765               __ec.clear();
1766               return __result;
1767             }
1768           __ec.assign(errno, generic_category());
1769 #else
1770           __ec = std::make_error_code(errc::operation_not_supported);
1771 #endif
1772           return 0;
1773         }
1774
1775       template<class _ConstBufferSequence, class _CompletionToken>
1776         __deduced_t<_CompletionToken, void(error_code, size_t)>
1777         async_send(const _ConstBufferSequence& __buffers,
1778                    _CompletionToken&& __token)
1779         {
1780           return async_send(__buffers, socket_base::message_flags(),
1781                             std::forward<_CompletionToken>(__token));
1782         }
1783
1784       template<class _ConstBufferSequence, class _CompletionToken>
1785         __deduced_t<_CompletionToken, void(error_code, size_t)>
1786         async_send(const _ConstBufferSequence& __buffers,
1787                    socket_base::message_flags __flags,
1788                    _CompletionToken&& __token)
1789         {
1790           async_completion<_CompletionToken, void(error_code, size_t)>
1791             __init{__token};
1792
1793           if (__buffer_empty(__buffers))
1794             {
1795               auto __ex = net::get_associated_executor(
1796                   __init.completion_handler, this->get_executor());
1797               auto __a = get_associated_allocator(
1798                   __init.completion_handler, std::allocator<void>());
1799               __ex.post(
1800                   [__h=std::move(__init.completion_handler)] () mutable
1801                   { __h(error_code{}, 0); }, __a);
1802               return __init.result.get();
1803             }
1804
1805           this->get_executor().context().async_wait(this->native_handle(),
1806               (int) socket_base::wait_write,
1807               [__h = std::move(__init.completion_handler),
1808                &__buffers, __flags = static_cast<int>(__flags),
1809                __fd = this->native_handle()]
1810               (error_code __ec) mutable {
1811                   if (__ec)
1812                     {
1813                       __h(__ec);
1814                       return;
1815                     }
1816 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1817                   socket_base::__msg_hdr __msg(__buffers);
1818                   ssize_t __result = ::sendmsg(__fd, &__msg, __flags);
1819                   if (__result == -1)
1820                     {
1821                       __ec.assign(errno, generic_category());
1822                       __result = 0;
1823                     }
1824                   else
1825                     __ec.clear();
1826                   __h(__ec, __result);
1827 #else
1828                   __h(std::make_error_code(errc::operation_not_supported), 0);
1829 #endif
1830               });
1831           return __init.result.get();
1832         }
1833
1834       template<class _MutableBufferSequence>
1835         size_t
1836         read_some(const _MutableBufferSequence& __buffers)
1837         {
1838           return receive(__buffers,
1839                          __throw_on_error{"basic_stream_socket::read_some"});
1840         }
1841
1842       template<class _MutableBufferSequence>
1843         size_t
1844         read_some(const _MutableBufferSequence& __buffers, error_code& __ec)
1845         { return receive(__buffers, __ec); }
1846
1847       template<class _MutableBufferSequence, class _CompletionToken>
1848         __deduced_t<_CompletionToken, void(error_code, size_t)>
1849         async_read_some(const _MutableBufferSequence& __buffers,
1850                         _CompletionToken&& __token)
1851         {
1852           return async_receive(__buffers,
1853                                std::forward<_CompletionToken>(__token));
1854         }
1855
1856       template<class _ConstBufferSequence>
1857         size_t
1858         write_some(const _ConstBufferSequence& __buffers)
1859         {
1860           return send(__buffers,
1861                       __throw_on_error{"basic_stream_socket:write_some"});
1862         }
1863
1864       template<class _ConstBufferSequence>
1865         size_t
1866         write_some(const _ConstBufferSequence& __buffers, error_code& __ec)
1867         {  return send(__buffers, __ec); }
1868
1869       template<class _ConstBufferSequence, class _CompletionToken>
1870         __deduced_t<_CompletionToken, void(error_code, size_t)>
1871         async_write_some(const _ConstBufferSequence& __buffers,
1872                               _CompletionToken&& __token)
1873         {
1874           return async_send(__buffers,
1875                             std::forward<_CompletionToken>(__token));
1876         }
1877     };
1878
1879   template<typename _AcceptableProtocol>
1880     class basic_socket_acceptor
1881     : public socket_base, private __basic_socket_impl<_AcceptableProtocol>
1882     {
1883       using __base = __basic_socket_impl<_AcceptableProtocol>;
1884
1885     public:
1886       // types:
1887
1888       using executor_type = io_context::executor_type;
1889       using native_handle_type = int;
1890       using protocol_type = _AcceptableProtocol;
1891       using endpoint_type = typename protocol_type::endpoint;
1892       using socket_type = typename protocol_type::socket;
1893
1894       static_assert(__detail::__acceptable_protocol<protocol_type>,
1895                     "protocol_type meets the AcceptableProtocol requirements");
1896
1897       // construct / copy / destroy:
1898
1899       explicit
1900       basic_socket_acceptor(io_context& __ctx)
1901       : __base(__ctx), _M_protocol(endpoint_type{}.protocol()) { }
1902
1903       basic_socket_acceptor(io_context& __ctx,
1904                             const protocol_type& __protocol)
1905       : __base(__ctx), _M_protocol(__protocol)
1906       { open(__protocol); }
1907
1908       basic_socket_acceptor(io_context& __ctx, const endpoint_type& __endpoint,
1909                             [[__maybe_unused__]] bool __reuse_addr = true)
1910       : basic_socket_acceptor(__ctx, __endpoint.protocol())
1911       {
1912 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
1913         if (__reuse_addr)
1914           set_option(reuse_address(true));
1915 #endif
1916         bind(__endpoint);
1917         listen();
1918       }
1919
1920       basic_socket_acceptor(io_context& __ctx, const protocol_type& __protocol,
1921                             const native_handle_type& __native_acceptor)
1922       : basic_socket_acceptor(__ctx, __protocol)
1923       { assign(__protocol, __native_acceptor); }
1924
1925       basic_socket_acceptor(const basic_socket_acceptor&) = delete;
1926
1927       basic_socket_acceptor(basic_socket_acceptor&&) = default;
1928
1929       template<typename _OtherProtocol, typename _Requires
1930                = _Require<is_convertible<_OtherProtocol, protocol_type>>>
1931         basic_socket_acceptor(basic_socket_acceptor<_OtherProtocol>&& __rhs)
1932         : __base(std::move(__rhs)) { }
1933
1934       ~basic_socket_acceptor() = default;
1935
1936       basic_socket_acceptor& operator=(const basic_socket_acceptor&) = delete;
1937
1938       basic_socket_acceptor& operator=(basic_socket_acceptor&&) = default;
1939
1940       template<class _OtherProtocol>
1941         enable_if_t<is_convertible<_OtherProtocol, protocol_type>::value,
1942                     basic_socket_acceptor&>
1943         operator=(basic_socket_acceptor<_OtherProtocol>&& __rhs)
1944         {
1945           __base::operator=(std::move(__rhs));
1946           return *this;
1947         }
1948
1949       // basic_socket_acceptor operations:
1950
1951       executor_type get_executor() noexcept { return __base::get_executor(); }
1952
1953       native_handle_type
1954       native_handle() noexcept { return __base::native_handle(); }
1955
1956       void
1957       open(const protocol_type& __protocol = protocol_type())
1958       { open(__protocol, __throw_on_error{"basic_socket_acceptor::open"}); }
1959
1960       void
1961       open(const protocol_type& __protocol, error_code& __ec)
1962       { __base::open(__protocol, __ec); }
1963
1964       void
1965       assign(const protocol_type& __protocol,
1966              const native_handle_type& __native_acceptor)
1967       {
1968         assign(__protocol, __native_acceptor,
1969                __throw_on_error{"basic_socket_acceptor::assign"});
1970       }
1971
1972       void
1973       assign(const protocol_type& __protocol,
1974              const native_handle_type& __native_acceptor,
1975              error_code& __ec)
1976       { __base::assign(__protocol, __native_acceptor, __ec); }
1977
1978       native_handle_type release()
1979       { return release(__throw_on_error{"basic_socket_acceptor::release"}); }
1980
1981       native_handle_type release(error_code& __ec)
1982       { return __base::release(__ec); }
1983
1984       _GLIBCXX_NODISCARD bool
1985       is_open() const noexcept { return __base::is_open(); }
1986
1987       void
1988       close() { close(__throw_on_error{"basic_socket_acceptor::close"}); }
1989
1990       void
1991       close(error_code& __ec) { __base::_close(__ec); }
1992
1993       void
1994       cancel() { cancel(__throw_on_error{"basic_socket_acceptor::cancel"}); }
1995
1996       void
1997       cancel(error_code& __ec) { __base::cancel(__ec); }
1998
1999       template<typename _SettableSocketOption>
2000         void
2001         set_option(const _SettableSocketOption& __option)
2002         {
2003           set_option(__option,
2004                      __throw_on_error{"basic_socket_acceptor::set_option"});
2005         }
2006
2007       template<typename _SettableSocketOption>
2008         void
2009         set_option(const _SettableSocketOption& __option, error_code& __ec)
2010         { __base::set_option(__option, __ec); }
2011
2012       template<typename _GettableSocketOption>
2013         void
2014         get_option(_GettableSocketOption& __option) const
2015         {
2016           get_option(__option,
2017                      __throw_on_error{"basic_socket_acceptor::get_option"});
2018         }
2019
2020       template<typename _GettableSocketOption>
2021         void
2022         get_option(_GettableSocketOption& __option, error_code& __ec) const
2023         { __base::get_option(__option, __ec); }
2024
2025       template<typename _IoControlCommand>
2026         void
2027         io_control(_IoControlCommand& __command)
2028         {
2029           io_control(__command,
2030                      __throw_on_error{"basic_socket_acceptor::io_control"});
2031         }
2032
2033       template<typename _IoControlCommand>
2034         void
2035         io_control(_IoControlCommand& __command, error_code& __ec)
2036         { __base::io_control(__command, __ec); }
2037
2038       void
2039       non_blocking(bool __mode)
2040       {
2041         non_blocking(__mode,
2042                      __throw_on_error{"basic_socket_acceptor::non_blocking"});
2043       }
2044
2045       void
2046       non_blocking(bool __mode, error_code& __ec)
2047       { __base::non_blocking(__mode, __ec); }
2048
2049       bool non_blocking() const { return __base::non_blocking(); }
2050
2051       void
2052       native_non_blocking(bool __mode)
2053       {
2054         native_non_blocking(__mode, __throw_on_error{
2055             "basic_socket_acceptor::native_non_blocking"});
2056       }
2057
2058       void
2059       native_non_blocking(bool __mode, error_code& __ec)
2060       { __base::native_non_blocking(__mode, __ec); }
2061
2062       bool
2063       native_non_blocking() const
2064       { return __base::native_non_blocking(); }
2065
2066       void
2067       bind(const endpoint_type& __endpoint)
2068       {
2069         return bind(__endpoint,
2070                     __throw_on_error{"basic_socket_acceptor::bind"});
2071       }
2072
2073       void
2074       bind(const endpoint_type& __endpoint, error_code& __ec)
2075       { __base::bind(__endpoint, __ec); }
2076
2077       void
2078       listen(int __backlog = max_listen_connections)
2079       {
2080         return listen(__backlog,
2081                       __throw_on_error{"basic_socket_acceptor::listen"});
2082       }
2083
2084       void
2085       listen(int __backlog, error_code& __ec)
2086       {
2087 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
2088         if (::listen(native_handle(), __backlog) == -1)
2089           __ec.assign(errno, generic_category());
2090         else
2091           __ec.clear();
2092 #else
2093         __ec = std::make_error_code(errc::operation_not_supported);
2094 #endif
2095       }
2096
2097       endpoint_type
2098       local_endpoint() const
2099       {
2100         return local_endpoint(
2101             __throw_on_error{"basic_socket_acceptor::local_endpoint"});
2102       }
2103
2104       endpoint_type
2105       local_endpoint(error_code& __ec) const
2106       { return __base::local_endpoint(__ec); }
2107
2108       void
2109       enable_connection_aborted(bool __mode)
2110       { __base::_M_bits.enable_connection_aborted = __mode; }
2111
2112       bool
2113       enable_connection_aborted() const
2114       { return __base::_M_bits.enable_connection_aborted; }
2115
2116       socket_type
2117       accept()
2118       { return accept(__throw_on_error{"basic_socket_acceptor::accept"}); }
2119
2120       socket_type
2121       accept(error_code& __ec)
2122       { return accept(get_executor().context(), __ec); }
2123
2124       socket_type accept(io_context& __ctx)
2125       {
2126         return accept(__ctx,
2127                       __throw_on_error{"basic_socket_acceptor::accept"});
2128       }
2129
2130       socket_type
2131       accept(io_context& __ctx, error_code& __ec)
2132       {
2133 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
2134         do
2135           {
2136             int __h = ::accept(native_handle(), nullptr, 0);
2137             if (__h != -1)
2138               {
2139                 __ec.clear();
2140                 return socket_type{__ctx, _M_protocol, __h};
2141               }
2142           } while (errno == ECONNABORTED && enable_connection_aborted());
2143         __ec.assign(errno, generic_category());
2144 #else
2145         __ec = std::make_error_code(errc::operation_not_supported);
2146 #endif
2147         return socket_type{__ctx};
2148       }
2149
2150       template<class _CompletionToken>
2151         __deduced_t<_CompletionToken, void(error_code, socket_type)>
2152         async_accept(_CompletionToken&& __token)
2153         {
2154           return async_accept(get_executor().context(),
2155                               std::forward<_CompletionToken>(__token));
2156         }
2157
2158       template<class _CompletionToken>
2159         __deduced_t<_CompletionToken, void(error_code, socket_type)>
2160         async_accept(io_context& __ctx, _CompletionToken&& __token)
2161         {
2162           async_completion<_CompletionToken, void(error_code, socket_type)>
2163             __init{__token};
2164
2165           __ctx.async_wait(native_handle(),
2166               (int) socket_base::wait_read,
2167               [__h = std::move(__init.completion_handler),
2168                __connabort = enable_connection_aborted(),
2169                __fd = native_handle(),
2170                __protocol = _M_protocol,
2171                &__ctx
2172               ]
2173               (error_code __ec) mutable {
2174                   if (__ec)
2175                     {
2176                       __h(__ec, socket_type(__ctx));
2177                       return;
2178                     }
2179 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
2180                   do
2181                     {
2182                       int __newfd = ::accept(__fd, nullptr, 0);
2183                       if (__newfd != -1)
2184                         {
2185                           __ec.clear();
2186                           __h(__ec, socket_type{__ctx, __protocol, __newfd});
2187                           return;
2188                         }
2189                     } while (errno == ECONNABORTED && __connabort);
2190                   __ec.assign(errno, generic_category());
2191                   __h(__ec, socket_type(__ctx));
2192 #else
2193                   __h(std::make_error_code(errc::operation_not_supported), 0);
2194 #endif
2195               });
2196           return __init.result.get();
2197         }
2198
2199       socket_type
2200       accept(endpoint_type& __endpoint)
2201       {
2202         return accept(get_executor().context(), __endpoint,
2203                       __throw_on_error{"basic_socket_acceptor::accept"});
2204       }
2205
2206       socket_type
2207       accept(endpoint_type& __endpoint, error_code& __ec)
2208       { return accept(get_executor().context(), __endpoint, __ec); }
2209
2210       socket_type
2211       accept(io_context& __ctx, endpoint_type& __endpoint)
2212       {
2213         return accept(__ctx, __endpoint,
2214                       __throw_on_error{"basic_socket_acceptor::accept"});
2215       }
2216
2217       socket_type
2218       accept(io_context& __ctx, endpoint_type& __endpoint, error_code& __ec)
2219       {
2220 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
2221         do
2222           {
2223             socklen_t __len = __endpoint.capacity();
2224             int __h = ::accept(native_handle(), (sockaddr*)__endpoint.data(),
2225                                &__len);
2226             if (__h != -1)
2227               {
2228                 __endpoint.resize(__len);
2229                 return socket_type{__ctx, _M_protocol, __h};
2230               }
2231           } while (errno == ECONNABORTED && enable_connection_aborted());
2232         __ec.assign(errno, generic_category());
2233 #else
2234         __ec = std::make_error_code(errc::operation_not_supported);
2235 #endif
2236         return socket_type{__ctx};
2237       }
2238
2239       template<class _CompletionToken>
2240         __deduced_t<_CompletionToken, void(error_code, socket_type)>
2241         async_accept(endpoint_type& __endpoint,
2242                              _CompletionToken&& __token)
2243         {
2244           return async_accept(get_executor().context(), __endpoint,
2245                               std::forward<_CompletionToken>(__token));
2246         }
2247
2248       template<class _CompletionToken>
2249         __deduced_t<_CompletionToken, void(error_code, socket_type)>
2250         async_accept(io_context& __ctx, endpoint_type& __endpoint,
2251                              _CompletionToken&& __token)
2252         {
2253           async_completion<_CompletionToken, void(error_code, socket_type)>
2254             __init{__token};
2255
2256           __ctx.async_wait(native_handle(),
2257               (int) socket_base::wait_read,
2258               [__h = std::move(__init.completion_handler),
2259               __ep = std::move(__endpoint),
2260                __connabort = enable_connection_aborted(),
2261                __fd = native_handle(),
2262                &__ctx
2263               ]
2264               (error_code __ec) mutable {
2265                   if (__ec)
2266                     {
2267                       __h(__ec, socket_type(__ctx));
2268                       return;
2269                     }
2270 #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H
2271                   do
2272                     {
2273                       socklen_t __len = __ep.capacity();
2274                       int __newfd = ::accept(__fd, __ep.data, &__len);
2275                       if (__newfd != -1)
2276                         {
2277                           __ep.resize(__len);
2278                           auto __protocol = __ep.protocol();
2279                           __ec.clear();
2280                           __h(__ec, socket_type{__ctx, __protocol, __newfd});
2281                           return;
2282                         }
2283                     } while (errno == ECONNABORTED && __connabort);
2284                   __ec.assign(errno, generic_category());
2285 #else
2286                   __ec = std::make_error_code(errc::operation_not_supported);
2287 #endif
2288                   __h(__ec, socket_type(__ctx));
2289               });
2290           return __init.result.get();
2291         }
2292
2293       void
2294       wait(wait_type __w)
2295       { wait(__w, __throw_on_error{"basic_socket_acceptor::wait"}); }
2296
2297       void
2298       wait(wait_type __w, error_code& __ec)
2299       {
2300 #ifdef _GLIBCXX_HAVE_POLL_H
2301         ::pollfd __fds;
2302         __fds.fd = native_handle();
2303         __fds.events = __w; // __w | POLLIN;
2304         if (::poll(&__fds, 1, -1) == -1)
2305           __ec.assign(errno, generic_category());
2306         else
2307           __ec.clear();
2308 #else
2309         __ec = std::make_error_code(errc::operation_not_supported);
2310 #endif
2311       }
2312
2313       template<class _CompletionToken>
2314         __deduced_t<_CompletionToken, void(error_code)>
2315         async_wait(wait_type __w, _CompletionToken&& __token)
2316         {
2317           async_completion<_CompletionToken, void(error_code)> __init{__token};
2318           get_executor().context().async_wait( native_handle(),
2319               static_cast<int>(__w),
2320               [__h = std::move(__init.completion_handler)]
2321               (error_code __ec) mutable {
2322                   __h(__ec);
2323               });
2324           return __init.result.get();
2325         }
2326
2327     private:
2328       protocol_type _M_protocol;
2329     };
2330
2331   /// @}
2332
2333   /** @brief Socket streams
2334    * @{
2335    */
2336
2337   template<typename _Protocol, typename _Clock, typename _WaitTraits>
2338     class basic_socket_streambuf : public basic_streambuf<char>
2339     {
2340     public:
2341       // types:
2342
2343       using protocol_type = _Protocol;
2344       using endpoint_type = typename protocol_type::endpoint;
2345       using clock_type = _Clock;
2346       using time_point = typename clock_type::time_point;
2347       using duration = typename clock_type::duration;
2348       using wait_traits_type = _WaitTraits;
2349
2350       // construct / copy / destroy:
2351
2352       basic_socket_streambuf() : _M_socket(_S_ctx()) { }
2353
2354       explicit
2355       basic_socket_streambuf(basic_stream_socket<protocol_type> __s)
2356       : _M_socket(std::move(__s)) { }
2357
2358       basic_socket_streambuf(const basic_socket_streambuf&) = delete;
2359
2360       basic_socket_streambuf(basic_socket_streambuf&& __rhs); // TODO
2361
2362
2363       virtual ~basic_socket_streambuf(); // TODO
2364
2365       basic_socket_streambuf& operator=(const basic_socket_streambuf&) = delete;
2366
2367       basic_socket_streambuf& operator=(basic_socket_streambuf&& __rhs); // TODO
2368
2369       // members:
2370
2371       basic_socket_streambuf* connect(const endpoint_type& __e); // TODO
2372
2373       template<typename... _Args>
2374         basic_socket_streambuf* connect(_Args&&... ); // TODO
2375
2376       basic_socket_streambuf* close(); // TODO
2377
2378       basic_socket<protocol_type>& socket() { return _M_socket; }
2379
2380       error_code error() const noexcept { return _M_ec; }
2381
2382       time_point expiry() const { return _M_expiry; }
2383
2384       void
2385       expires_at(const time_point& __t)
2386       { _M_expiry = __t; }
2387
2388       void
2389       expires_after(const duration& __d)
2390       { expires_at(clock_type::now() + __d); }
2391
2392     protected:
2393       // overridden virtual functions: // TODO
2394       virtual int_type underflow() override;
2395       virtual int_type pbackfail(int_type __c = traits_type::eof()) override;
2396       virtual int_type overflow(int_type __c = traits_type::eof()) override;
2397       virtual int sync() override;
2398       virtual streambuf* setbuf(char_type* __s, streamsize __n) override;
2399
2400     private:
2401       static io_context&
2402       _S_ctx()
2403       {
2404         static io_context __ctx;
2405         return __ctx;
2406       }
2407
2408       basic_stream_socket<protocol_type> _M_socket;
2409       error_code _M_ec;
2410       time_point _M_expiry{ time_point::max() };
2411     };
2412
2413   template<typename _Protocol, class _Clock, typename _WaitTraits>
2414     class basic_socket_iostream : public basic_iostream<char>
2415     {
2416       using __streambuf_type
2417         = basic_socket_streambuf<_Protocol, _Clock, _WaitTraits>;
2418
2419     public:
2420       // types:
2421
2422       using protocol_type = _Protocol;
2423       using endpoint_type = typename protocol_type::endpoint;
2424       using clock_type = _Clock;
2425       using time_point = typename clock_type::time_point;
2426       using duration = typename clock_type::duration;
2427       using wait_traits_type = _WaitTraits;
2428
2429       // construct / copy / destroy:
2430
2431       // TODO base-from-member ?
2432       basic_socket_iostream() : basic_iostream(nullptr), _M_sb()
2433       {
2434         this->init(std::addressof(_M_sb));
2435         this->setf(std::ios::unitbuf);
2436       }
2437
2438       explicit
2439       basic_socket_iostream(basic_stream_socket<protocol_type> __s)
2440       : basic_iostream(nullptr), _M_sb(std::move(__s))
2441       {
2442         this->init(std::addressof(_M_sb));
2443         this->setf(std::ios::unitbuf);
2444       }
2445
2446       basic_socket_iostream(const basic_socket_iostream&) = delete;
2447
2448       basic_socket_iostream(basic_socket_iostream&& __rhs)
2449       : basic_iostream(nullptr), _M_sb(std::move(__rhs._M_sb))
2450         // XXX ???     ^^^^^^^
2451       {
2452         // XXX ??? this->init(std::addressof(_M_sb));
2453         this->set_rdbuf(std::addressof(_M_sb));
2454       }
2455
2456       template<typename... _Args>
2457         explicit
2458         basic_socket_iostream(_Args&&... __args)
2459         : basic_iostream(nullptr), _M_sb()
2460         {
2461           this->init(std::addressof(_M_sb));
2462           this->setf(std::ios::unitbuf);
2463           connect(forward<_Args>(__args)...);
2464         }
2465
2466       basic_socket_iostream& operator=(const basic_socket_iostream&) = delete;
2467
2468       basic_socket_iostream& operator=(basic_socket_iostream&& __rhs); // TODO
2469
2470       // members:
2471
2472       template<typename... _Args>
2473         void
2474         connect(_Args&&... __args)
2475         {
2476           if (rdbuf()->connect(forward<_Args>(__args)...) == nullptr)
2477             this->setstate(failbit);
2478         }
2479
2480       void
2481       close()
2482       {
2483         if (rdbuf()->close() == nullptr)
2484           this->setstate(failbit);
2485       }
2486
2487       basic_socket_streambuf<protocol_type, clock_type, wait_traits_type>*
2488       rdbuf() const
2489       { return const_cast<__streambuf_type*>(std::addressof(_M_sb)); }
2490
2491       basic_socket<protocol_type>& socket() { return rdbuf()->socket(); }
2492       error_code error() const noexcept { return rdbuf()->error(); }
2493
2494       time_point expiry() const { return rdbuf()->expiry(); }
2495       void expires_at(const time_point& __t) { rdbuf()->expires_at(__t); }
2496       void expires_after(const duration& __d) { rdbuf()->expires_after(__d); }
2497
2498     private:
2499       __streambuf_type _M_sb;
2500     };
2501
2502   /// @}
2503
2504   /** @brief synchronous connect operations
2505    * @{
2506    */
2507
2508   template<typename _Protocol, typename _EndpointSequence,
2509            typename _ConnectCondition>
2510     inline typename _Protocol::endpoint
2511     connect(basic_socket<_Protocol>& __s,
2512             const _EndpointSequence& __endpoints,
2513             _ConnectCondition __c, error_code& __ec)
2514     {
2515       __ec.clear();
2516       bool __found = false;
2517       for (auto& __ep : __endpoints)
2518         {
2519           if (__c(__ec, __ep))
2520             {
2521               __found = true;
2522               __s.close(__ec);
2523               if (!__ec)
2524                 __s.open(__ep.protocol(), __ec);
2525               if (!__ec)
2526                 __s.connect(__ep, __ec);
2527               if (!__ec)
2528                 return __ep;
2529             }
2530         }
2531       if (!__found)
2532         __ec = socket_errc::not_found;
2533       return typename _Protocol::endpoint{};
2534     }
2535
2536   template<typename _Protocol, typename _InputIterator,
2537            typename _ConnectCondition>
2538     inline _InputIterator
2539     connect(basic_socket<_Protocol>& __s,
2540             _InputIterator __first, _InputIterator __last,
2541             _ConnectCondition __c, error_code& __ec)
2542     {
2543       __ec.clear();
2544       bool __found = false;
2545       for (auto __i = __first; __i != __last; ++__i)
2546         {
2547           if (__c(__ec, *__i))
2548             {
2549               __found = true;
2550               __s.close(__ec);
2551               if (!__ec)
2552                 __s.open(typename _Protocol::endpoint(*__i).protocol(), __ec);
2553               if (!__ec)
2554                 __s.connect(*__i, __ec);
2555               if (!__ec)
2556                 return __i;
2557             }
2558         }
2559       if (!__found)
2560         __ec = socket_errc::not_found;
2561       return __last;
2562     }
2563
2564   template<typename _Protocol, typename _EndpointSequence,
2565            typename _ConnectCondition>
2566     inline typename _Protocol::endpoint
2567     connect(basic_socket<_Protocol>& __s,
2568             const _EndpointSequence& __endpoints,
2569             _ConnectCondition __c)
2570     {
2571       return net::connect(__s, __endpoints, __c, __throw_on_error{"connect"});
2572     }
2573
2574   template<typename _Protocol, typename _InputIterator,
2575            typename _ConnectCondition>
2576     inline _InputIterator
2577     connect(basic_socket<_Protocol>& __s,
2578             _InputIterator __first, _InputIterator __last,
2579             _ConnectCondition __c)
2580     {
2581       return net::connect(__s, __first, __last, __c,
2582                           __throw_on_error{"connect"});
2583     }
2584
2585   template<typename _Protocol, typename _EndpointSequence>
2586     inline typename _Protocol::endpoint
2587     connect(basic_socket<_Protocol>& __s,
2588             const _EndpointSequence& __endpoints)
2589     {
2590       return net::connect(__s, __endpoints, [](auto, auto){ return true; },
2591                           __throw_on_error{"connect"});
2592     }
2593
2594   template<typename _Protocol, typename _EndpointSequence>
2595     inline typename _Protocol::endpoint
2596     connect(basic_socket<_Protocol>& __s,
2597             const _EndpointSequence& __endpoints,
2598             error_code& __ec)
2599     {
2600       return net::connect(__s, __endpoints, [](auto, auto){ return true; },
2601                           __ec);
2602     }
2603
2604   template<typename _Protocol, typename _InputIterator>
2605     inline _InputIterator
2606     connect(basic_socket<_Protocol>& __s,
2607             _InputIterator __first, _InputIterator __last)
2608     {
2609       return net::connect(__s, __first, __last, [](auto, auto){ return true; },
2610                           __throw_on_error{"connect"});
2611     }
2612
2613   template<typename _Protocol, typename _InputIterator>
2614     inline _InputIterator
2615     connect(basic_socket<_Protocol>& __s,
2616             _InputIterator __first, _InputIterator __last,
2617             error_code& __ec)
2618     {
2619       return net::connect(__s, __first, __last, [](auto, auto){ return true; },
2620                           __ec);
2621     }
2622
2623   /// @}
2624
2625   /** @brief asynchronous connect operations
2626    * @{
2627    */
2628
2629   template<typename _Protocol, typename _EndpointSequence,
2630            typename _ConnectCondition, typename _CompletionToken>
2631     inline
2632     __deduced_t<_CompletionToken,
2633                 void(error_code, typename _Protocol::endpoint)>
2634     async_connect(basic_socket<_Protocol>& __s,
2635                   const _EndpointSequence& __endpoints,
2636                   _ConnectCondition __c, _CompletionToken&& __token); // TODO
2637
2638   template<typename _Protocol, typename _EndpointSequence,
2639            typename _CompletionToken>
2640     inline
2641     __deduced_t<_CompletionToken,
2642                 void(error_code, typename _Protocol::endpoint)>
2643     async_connect(basic_socket<_Protocol>& __s,
2644                   const _EndpointSequence& __endpoints,
2645                   _CompletionToken&& __token)
2646     {
2647       return net::async_connect(__s, __endpoints,
2648                                 [](auto, auto){ return true; },
2649                                 forward<_CompletionToken>(__token));
2650     }
2651
2652   template<typename _Protocol, typename _InputIterator,
2653            typename _ConnectCondition, typename _CompletionToken>
2654     inline
2655     __deduced_t<_CompletionToken, void(error_code, _InputIterator)>
2656     async_connect(basic_socket<_Protocol>& __s,
2657                   _InputIterator __first, _InputIterator __last,
2658                   _ConnectCondition __c, _CompletionToken&& __token); // TODO
2659
2660   template<typename _Protocol, typename _InputIterator,
2661            typename _CompletionToken>
2662     inline
2663     __deduced_t<_CompletionToken, void(error_code, _InputIterator)>
2664     async_connect(basic_socket<_Protocol>& __s,
2665                   _InputIterator __first, _InputIterator __last,
2666                   _CompletionToken&& __token)
2667     {
2668       return net::async_connect(__s, __first, __last,
2669                                 [](auto, auto){ return true; },
2670                                 forward<_CompletionToken>(__token));
2671     }
2672
2673   /// @}
2674
2675 #endif  // _GLIBCXX_HAVE_UNISTD_H
2676
2677   /// @}
2678
2679 } // namespace v1
2680 } // namespace net
2681 } // namespace experimental
2682
2683 _GLIBCXX_END_NAMESPACE_VERSION
2684 } // namespace std
2685
2686 #endif // C++14
2687
2688 #endif // _GLIBCXX_EXPERIMENTAL_SOCKET