visus
/
toolchain-gcc-arm-embedded
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
2 Revīzijas
1 Atzars
Atzars: main
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'main'
${ noResults }
toolchain-gcc-arm-embedded/arm-none-eabi/include/c++/10.2.1/experimental/internet

2428 rindas
64KB
Neapstrādāts Patstāvīgā saite Vainot Vēsture 

  1. // <experimental/internet> -*- C++ -*-

  2. 

  3. // Copyright (C) 2015-2020 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/internet

  26.  *  This is a TS C++ Library header.

  27.  *  @ingroup networking-ts

  28.  */

  29. 

  30. #ifndef _GLIBCXX_EXPERIMENTAL_INTERNET

  31. #define _GLIBCXX_EXPERIMENTAL_INTERNET

  32. 

  33. #pragma GCC system_header

  34. 

  35. #if __cplusplus >= 201402L

  36. 

  37. #include <experimental/netfwd>

  38. #include <experimental/io_context>

  39. #include <experimental/bits/net.h>

  40. #include <array>

  41. #include <forward_list>

  42. #include <sstream>

  43. #include <cstdint>

  44. #include <experimental/string_view>

  45. #ifdef _GLIBCXX_HAVE_UNISTD_H

  46. # include <unistd.h>

  47. #endif

  48. #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H

  49. # include <sys/socket.h>	// AF_INET, AF_INET6, SOCK_DGRAM, SOCK_STREAM

  50. #endif

  51. #ifdef _GLIBCXX_HAVE_ARPA_INET_H

  52. # include <arpa/inet.h>		// inet_ntop

  53. #endif

  54. #ifdef _GLIBCXX_HAVE_NETINET_IN_H

  55. # include <netinet/in.h>	// IPPROTO_IP

  56. #endif

  57. #ifdef _GLIBCXX_HAVE_NETINET_TCP_H

  58. # include <netinet/tcp.h>	// TCP_NODELAY

  59. #endif

  60. #ifdef _GLIBCXX_HAVE_NETDB_H

  61. # include <netdb.h>		// getaddrinfo etc.

  62. #endif

  63. 

  64. namespace std _GLIBCXX_VISIBILITY(default)

  65. {

  66. _GLIBCXX_BEGIN_NAMESPACE_VERSION

  67. namespace experimental

  68. {

  69. namespace net

  70. {

  71. inline namespace v1

  72. {

  73. namespace ip

  74. {

  75. 

  76.   /** @addtogroup networking-ts

  77.    *  @{

  78.    */

  79. 

  80. #ifdef _GLIBCXX_HAVE_NETDB_H

  81.   /** Error codes for resolver errors.

  82.    * @{

  83.    */

  84. 

  85.   enum class resolver_errc : int {

  86.     host_not_found = EAI_NONAME,

  87.     host_not_found_try_again = EAI_AGAIN,

  88.     service_not_found = EAI_SERVICE

  89.   };

  90. 

  91.   /// Error category for resolver errors.

  92.   inline const error_category& resolver_category() noexcept // TODO non-inline

  93.   {

  94.     struct __cat : error_category

  95.     {

  96.       const char* name() const noexcept { return "resolver"; }

  97.       std::string message(int __e) const { return ::gai_strerror(__e); }

  98.       virtual void __message(int) { } // TODO dual ABI XXX

  99.     };

  100.     static __cat __c;

  101.     return __c;

  102.   }

  103. 

  104.   error_code make_error_code(resolver_errc __e) noexcept

  105.   { return error_code(static_cast<int>(__e), resolver_category()); }

  106. 

  107.   error_condition make_error_condition(resolver_errc __e) noexcept

  108.   { return error_condition(static_cast<int>(__e), resolver_category()); }

  109. 

  110.   /// @}

  111. #endif

  112. 

  113.   typedef uint_least16_t port_type;	///< Type used for port numbers.

  114.   typedef uint_least32_t scope_id_type;	///< Type used for IPv6 scope IDs.

  115. 

  116.   /// Convenience alias for constraining allocators for strings.

  117.   template<typename _Alloc>

  118.     using __string_with

  119.       = enable_if_t<std::is_same<typename _Alloc::value_type, char>::value,

  120. 		    std::basic_string<char, std::char_traits<char>, _Alloc>>;

  121. 

  122.   /** Tag indicating conversion between IPv4 and IPv4-mapped IPv6 addresses.

  123.    * @{

  124.    */

  125. 

  126.   struct v4_mapped_t {};

  127.   constexpr v4_mapped_t v4_mapped;

  128. 

  129.   // @}

  130. 

  131.   /// An IPv4 address.

  132.   class address_v4

  133.   {

  134.   public:

  135.     // types:

  136.     typedef uint_least32_t uint_type;

  137. 

  138.     struct bytes_type : array<unsigned char, 4>

  139.     {

  140.       template<typename... _Tp>

  141. 	explicit constexpr

  142. 	bytes_type(_Tp... __tp)

  143. 	: array<unsigned char, 4>{{static_cast<unsigned char>(__tp)...}}

  144. 	{

  145. #if UCHAR_MAX > 0xFF

  146. 	  for (auto __b : *this)

  147. 	    if (__b > 0xFF)

  148. 	      __throw_out_of_range("invalid address_v4::bytes_type value");

  149. #endif

  150. 	}

  151.     };

  152. 

  153.     // constructors:

  154.     constexpr address_v4() noexcept : _M_addr(0) { }

  155. 

  156.     constexpr address_v4(const address_v4& a) noexcept = default;

  157. 

  158.     constexpr

  159.     address_v4(const bytes_type& __b)

  160.     : _M_addr((__b[0] << 24) | (__b[1] << 16) | (__b[2] << 8) | __b[3])

  161.     { }

  162. 

  163.     explicit constexpr

  164.     address_v4(uint_type __val) : _M_addr(_S_hton_32(__val))

  165.     {

  166. #if UINT_LEAST32_MAX > 0xFFFFFFFF

  167.       if (__val > 0xFFFFFFFF)

  168. 	__throw_out_of_range("invalid address_v4::uint_type value");

  169. #endif

  170.     }

  171. 

  172.     // assignment:

  173.     address_v4& operator=(const address_v4& a) noexcept = default;

  174. 

  175.     // members:

  176.     constexpr bool is_unspecified() const noexcept { return to_uint() == 0; }

  177. 

  178.     constexpr bool

  179.     is_loopback() const noexcept

  180.     { return (to_uint() & 0xFF000000) == 0x7F000000; }

  181. 

  182.     constexpr bool

  183.     is_multicast() const noexcept

  184.     { return (to_uint() & 0xF0000000) == 0xE0000000; }

  185. 

  186.     constexpr bytes_type

  187.     to_bytes() const noexcept

  188.     {

  189.       return bytes_type{

  190. 	  (_M_addr >> 24) & 0xFF,

  191. 	  (_M_addr >> 16) & 0xFF,

  192. 	  (_M_addr >> 8) & 0xFF,

  193. 	  _M_addr & 0xFF

  194.       };

  195.     }

  196. 

  197.     constexpr uint_type

  198.     to_uint() const noexcept { return _S_ntoh_32(_M_addr); }

  199. 

  200. #ifdef _GLIBCXX_HAVE_ARPA_INET_H

  201.     template<typename _Allocator = allocator<char>>

  202.       __string_with<_Allocator>

  203.       to_string(const _Allocator& __a = _Allocator()) const

  204.       {

  205. 	__string_with<_Allocator> __str(__a);

  206. 	__str.resize(INET6_ADDRSTRLEN);

  207. 	if (inet_ntop(AF_INET, &_M_addr, &__str.front(), __str.size()))

  208. 	  __str.erase(__str.find('\0'));

  209. 	else

  210. 	  __str.resize(0);

  211. 	return __str;

  212.       }

  213. #endif

  214. 

  215.     // static members:

  216.     static constexpr address_v4 any() noexcept { return address_v4{}; }

  217. 

  218.     static constexpr

  219.     address_v4 loopback() noexcept { return address_v4{0x7F000001}; }

  220. 

  221.     static constexpr

  222.     address_v4 broadcast() noexcept { return address_v4{0xFFFFFFFF}; }

  223. 

  224.   private:

  225.     template<typename _InternetProtocol>

  226.       friend class basic_endpoint;

  227. 

  228.     friend address_v4 make_address_v4(const char*, error_code&) noexcept;

  229. 

  230. #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__

  231.     static constexpr uint16_t _S_hton_16(uint16_t __h) { return __h; }

  232.     static constexpr uint16_t _S_ntoh_16(uint16_t __n) { return __n; }

  233.     static constexpr uint32_t _S_hton_32(uint32_t __h) { return __h; }

  234.     static constexpr uint32_t _S_ntoh_32(uint32_t __n) { return __n; }

  235. #else

  236.     static constexpr uint16_t

  237.     _S_hton_16(uint16_t __h) { return __builtin_bswap16(__h); }

  238. 

  239.     static constexpr uint16_t

  240.     _S_ntoh_16(uint16_t __n) { return __builtin_bswap16(__n); }

  241. 

  242.     static constexpr uint32_t

  243.     _S_hton_32(uint32_t __h) { return __builtin_bswap32(__h); }

  244. 

  245.     static constexpr uint32_t

  246.     _S_ntoh_32(uint32_t __n) { return __builtin_bswap32(__n); }

  247. #endif

  248. 

  249.     in_addr_t _M_addr; // network byte order

  250.   };

  251. 

  252.   /// An IPv6 address.

  253.   class address_v6

  254.   {

  255.   public:

  256.     // types:

  257.     struct bytes_type : array<unsigned char, 16>

  258.     {

  259.       template<typename... _Tp> explicit constexpr bytes_type(_Tp... __t)

  260. 	: array<unsigned char, 16>{{static_cast<unsigned char>(__t)...}} { }

  261.     };

  262. 

  263.     // constructors:

  264.     constexpr address_v6() noexcept : _M_bytes(), _M_scope_id() { }

  265. 

  266.     constexpr address_v6(const address_v6& __a) noexcept = default;

  267. 

  268.     constexpr

  269.     address_v6(const bytes_type& __bytes, scope_id_type __scope = 0)

  270.     : _M_bytes(__bytes), _M_scope_id(__scope)

  271.     { }

  272. 

  273.     // assignment:

  274.     address_v6& operator=(const address_v6& __a) noexcept = default;

  275. 

  276.     // members:

  277.     void scope_id(scope_id_type __id) noexcept { _M_scope_id = __id; }

  278. 

  279.     constexpr scope_id_type scope_id() const noexcept { return _M_scope_id; }

  280. 

  281.     constexpr bool

  282.     is_unspecified() const noexcept

  283.     {

  284.       for (int __i = 0; __i < 16; ++__i)

  285. 	if (_M_bytes[__i] != 0x00)

  286. 	  return false;

  287.       return _M_scope_id == 0;

  288.     }

  289. 

  290.     constexpr bool

  291.     is_loopback() const noexcept

  292.     {

  293.       for (int __i = 0; __i < 15; ++__i)

  294. 	if (_M_bytes[__i] != 0x00)

  295. 	  return false;

  296.       return _M_bytes[15] == 0x01 && _M_scope_id == 0;

  297.     }

  298. 

  299.     constexpr bool

  300.     is_multicast() const noexcept { return _M_bytes[0] == 0xFF; }

  301. 

  302.     constexpr bool

  303.     is_link_local() const noexcept

  304.     { return _M_bytes[0] == 0xFE && (_M_bytes[1] & 0xC0) == 0x80; }

  305. 

  306.     constexpr bool

  307.     is_site_local() const noexcept

  308.     { return _M_bytes[0] == 0xFE && (_M_bytes[1] & 0xC0) == 0xC0; }

  309. 

  310.     constexpr bool

  311.     is_v4_mapped() const noexcept

  312.     {

  313.       const bytes_type& __b = _M_bytes;

  314.       return __b[0] == 0 && __b[1] == 0 && __b[ 2] == 0    && __b[ 3] == 0

  315. 	  && __b[4] == 0 && __b[5] == 0 && __b[ 6] == 0    && __b[ 7] == 0

  316. 	  && __b[8] == 0 && __b[9] == 0 && __b[10] == 0xFF && __b[11] == 0xFF;

  317.     }

  318. 

  319.     constexpr bool

  320.     is_multicast_node_local() const noexcept

  321.     { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x01; }

  322. 

  323.     constexpr bool

  324.     is_multicast_link_local() const noexcept

  325.     { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x02; }

  326. 

  327.     constexpr bool

  328.     is_multicast_site_local() const noexcept

  329.     { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x05; }

  330. 

  331.     constexpr bool

  332.     is_multicast_org_local() const noexcept

  333.     { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x08; }

  334. 

  335.     constexpr bool

  336.     is_multicast_global() const noexcept

  337.     { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x0b; }

  338. 

  339.     constexpr bytes_type to_bytes() const noexcept { return _M_bytes; }

  340. 

  341. #ifdef _GLIBCXX_HAVE_ARPA_INET_H

  342.     template<typename _Allocator = allocator<char>>

  343.       __string_with<_Allocator>

  344.       to_string(const _Allocator& __a = _Allocator()) const

  345.       {

  346. 	__string_with<_Allocator> __str(__a);

  347. 	__str.resize(INET6_ADDRSTRLEN);

  348. 	if (inet_ntop(AF_INET6, &_M_bytes, &__str.front(), __str.size()))

  349. 	  __str.erase(__str.find('\0'));

  350. 	else

  351. 	  __str.resize(0);

  352. 	return __str;

  353.       }

  354. #endif

  355. 

  356.     // static members:

  357.     static constexpr address_v6

  358.     any() noexcept

  359.     {

  360.       address_v6 __addr;

  361.       __builtin_memcpy(&__addr._M_bytes, in6addr_any.s6_addr, 16);

  362.       return __addr;

  363.     }

  364. 

  365.     static constexpr address_v6

  366.     loopback() noexcept

  367.     {

  368.       address_v6 __addr;

  369.       __builtin_memcpy(&__addr._M_bytes, in6addr_loopback.s6_addr, 16);

  370.       return __addr;

  371.     }

  372. 

  373.   private:

  374.     template<typename _InternetProtocol>

  375.       friend class basic_endpoint;

  376. 

  377.     friend constexpr bool

  378.     operator==(const address_v6&, const address_v6&) noexcept;

  379. 

  380.     friend constexpr bool

  381.     operator< (const address_v6&, const address_v6&) noexcept;

  382. 

  383.     bytes_type _M_bytes;

  384.     scope_id_type _M_scope_id;

  385.   };

  386. 

  387.   /// Exception type thrown on misuse of IPv4 addresses as IPv6 or vice versa.

  388.   class bad_address_cast : public bad_cast

  389.   {

  390.   public:

  391.     bad_address_cast() { }

  392. 

  393.     const char* what() const noexcept { return "bad address cast"; }

  394.   };

  395. 

  396.   /// An IPv4 or IPv6 address.

  397.   class address

  398.   {

  399.   public:

  400.     // constructors:

  401.     constexpr address() noexcept : _M_v4(), _M_is_v4(true) { }

  402. 

  403.     constexpr

  404.     address(const address& __a) noexcept : _M_uninit(), _M_is_v4(__a._M_is_v4)

  405.     {

  406.       if (_M_is_v4)

  407. 	::new (std::addressof(_M_v4)) address_v4(__a.to_v4());

  408.       else

  409. 	::new (std::addressof(_M_v6)) address_v6(__a.to_v6());

  410.     }

  411. 

  412.     constexpr

  413.     address(const address_v4& __a) noexcept : _M_v4(__a), _M_is_v4(true) { }

  414. 

  415.     constexpr

  416.     address(const address_v6& __a) noexcept : _M_v6(__a), _M_is_v4(false) { }

  417. 

  418.     // assignment:

  419.     address&

  420.     operator=(const address& __a) noexcept

  421.     {

  422.       if (__a._M_is_v4)

  423. 	*this = __a.to_v4();

  424.       else

  425. 	*this = __a.to_v6();

  426.       return *this;

  427.     }

  428. 

  429.     address&

  430.     operator=(const address_v4& __a) noexcept

  431.     {

  432.       ::new (std::addressof(_M_v4)) address_v4(__a);

  433.       _M_is_v4 = true;

  434.       return *this;

  435.     }

  436. 

  437.     address&

  438.     operator=(const address_v6& __a) noexcept

  439.     {

  440.       ::new (std::addressof(_M_v6)) address_v6(__a);

  441.       _M_is_v4 = false;

  442.       return *this;

  443.     }

  444. 

  445.     // members:

  446. 

  447.     constexpr bool is_v4() const noexcept { return _M_is_v4; }

  448.     constexpr bool is_v6() const noexcept { return !_M_is_v4; }

  449. 

  450.     constexpr address_v4

  451.     to_v4() const

  452.     {

  453.       if (!is_v4())

  454. 	_GLIBCXX_THROW_OR_ABORT(bad_address_cast());

  455.       return _M_v4;

  456.     }

  457. 

  458.     constexpr address_v6

  459.     to_v6() const

  460.     {

  461.       if (!is_v6())

  462. 	_GLIBCXX_THROW_OR_ABORT(bad_address_cast());

  463.       return _M_v6;

  464.     }

  465. 

  466.     constexpr bool

  467.     is_unspecified() const noexcept

  468.     { return _M_is_v4 ? _M_v4.is_unspecified() : _M_v6.is_unspecified(); }

  469. 

  470.     constexpr bool

  471.     is_loopback() const noexcept

  472.     { return _M_is_v4 ? _M_v4.is_loopback() : _M_v6.is_loopback(); }

  473. 

  474.     constexpr bool

  475.     is_multicast() const noexcept

  476.     { return _M_is_v4 ? _M_v4.is_multicast() : _M_v6.is_multicast(); }

  477. 

  478.     template<typename _Allocator = allocator<char>>

  479.       __string_with<_Allocator>

  480.       to_string(const _Allocator& __a = _Allocator()) const

  481.       {

  482. 	if (_M_is_v4)

  483. 	  return to_v4().to_string(__a);

  484. 	return to_v6().to_string(__a);

  485.       }

  486. 

  487.   private:

  488.     template<typename _InternetProtocol>

  489.       friend class basic_endpoint;

  490. 

  491.     friend constexpr bool

  492.     operator==(const address&, const address&) noexcept;

  493. 

  494.     friend constexpr bool

  495.     operator<(const address&, const address&) noexcept;

  496. 

  497.     union {

  498.       address_v4 _M_v4;

  499.       address_v6 _M_v6;

  500.       bool	 _M_uninit;

  501.     };

  502.     bool _M_is_v4;

  503.   };

  504. 

  505.   /** ip::address_v4 comparisons

  506.    * @{

  507.    */

  508. 

  509.   constexpr bool

  510.   operator==(const address_v4& __a, const address_v4& __b) noexcept

  511.   { return __a.to_uint() == __b.to_uint(); }

  512. 

  513.   constexpr bool

  514.   operator!=(const address_v4& __a, const address_v4& __b) noexcept

  515.   { return !(__a == __b); }

  516. 

  517.   constexpr bool

  518.   operator< (const address_v4& __a, const address_v4& __b) noexcept

  519.   { return __a.to_uint() < __b.to_uint(); }

  520. 

  521.   constexpr bool

  522.   operator> (const address_v4& __a, const address_v4& __b) noexcept

  523.   { return __b < __a; }

  524. 

  525.   constexpr bool

  526.   operator<=(const address_v4& __a, const address_v4& __b) noexcept

  527.   { return !(__b < __a); }

  528. 

  529.   constexpr bool

  530.   operator>=(const address_v4& __a, const address_v4& __b) noexcept

  531.   { return !(__a < __b); }

  532. 

  533.   // @}

  534. 

  535.   /** ip::address_v6 comparisons

  536.    * @{

  537.    */

  538. 

  539.   constexpr bool

  540.   operator==(const address_v6& __a, const address_v6& __b) noexcept

  541.   {

  542.     const auto& __aa = __a._M_bytes;

  543.     const auto& __bb = __b._M_bytes;

  544.     int __i = 0;

  545.     for (; __i < 16 && __aa[__i] == __bb[__i]; ++__i)

  546.       ;

  547.     return __i == 16 ? __a.scope_id() == __b.scope_id() : false;

  548.   }

  549. 

  550.   constexpr bool

  551.   operator!=(const address_v6& __a, const address_v6& __b) noexcept

  552.   { return !(__a == __b); }

  553. 

  554.   constexpr bool

  555.   operator< (const address_v6& __a, const address_v6& __b) noexcept

  556.   {

  557.     const auto& __aa = __a._M_bytes;

  558.     const auto& __bb = __b._M_bytes;

  559.     int __i = 0;

  560.     for (; __i < 16 && __aa[__i] == __bb[__i]; ++__i)

  561.       ;

  562.     return __i == 16 ? __a.scope_id() < __b.scope_id() : __aa[__i] < __bb[__i];

  563.   }

  564. 

  565.   constexpr bool

  566.   operator> (const address_v6& __a, const address_v6& __b) noexcept

  567.   { return __b < __a; }

  568. 

  569.   constexpr bool

  570.   operator<=(const address_v6& __a, const address_v6& __b) noexcept

  571.   { return !(__b < __a); }

  572. 

  573.   constexpr bool

  574.   operator>=(const address_v6& __a, const address_v6& __b) noexcept

  575.   { return !(__a < __b); }

  576. 

  577.   // @}

  578. 

  579.   /** ip::address comparisons

  580.    * @{

  581.    */

  582. 

  583.   constexpr bool

  584.   operator==(const address& __a, const address& __b) noexcept

  585.   {

  586.     if (__a.is_v4())

  587.       return __b.is_v4() ? __a._M_v4 == __b._M_v4 : false;

  588.     return __b.is_v4() ? false : __a._M_v6 == __b._M_v6;

  589.   }

  590. 

  591.   constexpr bool

  592.   operator!=(const address& __a, const address& __b) noexcept

  593.   { return !(__a == __b); }

  594. 

  595.   constexpr bool

  596.   operator< (const address& __a, const address& __b) noexcept

  597.   {

  598.     if (__a.is_v4())

  599.       return __b.is_v4() ? __a._M_v4 < __b._M_v4 : true;

  600.     return __b.is_v4() ? false : __a._M_v6 < __b._M_v6;

  601.   }

  602. 

  603.   constexpr bool

  604.   operator> (const address& __a, const address& __b) noexcept

  605.   { return __b < __a; }

  606. 

  607.   constexpr bool

  608.   operator<=(const address& __a, const address& __b) noexcept

  609.   { return !(__b < __a); }

  610. 

  611.   constexpr bool

  612.   operator>=(const address& __a, const address& __b) noexcept

  613.   { return !(__a < __b); }

  614. 

  615.   // @}

  616. 

  617.   /** ip::address_v4 creation

  618.    * @{

  619.    */

  620. 

  621.   constexpr address_v4

  622.   make_address_v4(const address_v4::bytes_type& __b)

  623.   { return address_v4{__b}; }

  624. 

  625.   constexpr address_v4

  626.   make_address_v4(address_v4::uint_type __val)

  627.   { return address_v4{__val}; }

  628. 

  629.   constexpr address_v4

  630.   make_address_v4(v4_mapped_t, const address_v6& __a)

  631.   {

  632.     if (!__a.is_v4_mapped())

  633.       _GLIBCXX_THROW_OR_ABORT(bad_address_cast());

  634. 

  635.     const auto __v6b = __a.to_bytes();

  636.     return address_v4::bytes_type(__v6b[12], __v6b[13], __v6b[14], __v6b[15]);

  637.   }

  638. 

  639.   inline address_v4

  640.   make_address_v4(const char* __str, error_code& __ec) noexcept

  641.   {

  642.     address_v4 __a;

  643.     const int __res = ::inet_pton(AF_INET, __str, &__a._M_addr);

  644.     if (__res == 1)

  645.       {

  646. 	__ec.clear();

  647. 	return __a;

  648.       }

  649.     if (__res == 0)

  650.       __ec = std::make_error_code(std::errc::invalid_argument);

  651.     else

  652.       __ec.assign(errno, generic_category());

  653.     return {};

  654.   }

  655. 

  656.   inline address_v4

  657.   make_address_v4(const char* __str)

  658.   { return make_address_v4(__str, __throw_on_error{"make_address_v4"}); }

  659. 

  660.   inline address_v4

  661.   make_address_v4(const string& __str, error_code& __ec) noexcept

  662.   { return make_address_v4(__str.c_str(), __ec); }

  663. 

  664.   inline address_v4

  665.   make_address_v4(const string& __str)

  666.   { return make_address_v4(__str.c_str()); }

  667. 

  668.   inline address_v4

  669.   make_address_v4(string_view __str, error_code& __ec) noexcept

  670.   {

  671.     char __buf[INET_ADDRSTRLEN];

  672.     auto __len = __str.copy(__buf, sizeof(__buf));

  673.     if (__len == sizeof(__buf))

  674.       {

  675. 	__ec = std::make_error_code(std::errc::invalid_argument);

  676. 	return {};

  677.       }

  678.     __ec.clear();

  679.     __buf[__len] = '\0';

  680.     return make_address_v4(__buf, __ec);

  681.   }

  682. 

  683.   inline address_v4

  684.   make_address_v4(string_view __str)

  685.   { return make_address_v4(__str, __throw_on_error{"make_address_v4"}); }

  686. 

  687.   // @}

  688. 

  689.   /** ip::address_v6 creation

  690.    * @{

  691.    */

  692. 

  693.   constexpr address_v6

  694.   make_address_v6(const address_v6::bytes_type& __b, scope_id_type __scope = 0)

  695.   { return address_v6{__b, __scope}; }

  696. 

  697.   constexpr address_v6

  698.   make_address_v6(v4_mapped_t, const address_v4& __a) noexcept

  699.   {

  700.     const address_v4::bytes_type __v4b = __a.to_bytes();

  701.     address_v6::bytes_type __v6b(0, 0, 0, 0, 0, 0, 0, 0,

  702. 				 0, 0, 0xFF, 0xFF,

  703. 				 __v4b[0], __v4b[1], __v4b[2], __v4b[3]);

  704.     return address_v6(__v6b);

  705.   }

  706. 

  707.   inline address_v6

  708.   __make_address_v6(const char* __addr, const char* __scope, error_code& __ec)

  709.   {

  710.     address_v6::bytes_type __b;

  711.     int __res = ::inet_pton(AF_INET6, __addr, __b.data());

  712.     if (__res == 1)

  713.       {

  714. 	__ec.clear();

  715. 	if (!__scope)

  716. 	  {

  717. 	    return { __b };

  718. 	  }

  719. 

  720. 	char* __eptr;

  721. 	unsigned long __val = std::strtoul(__scope, &__eptr, 10);

  722. 	if (__eptr != __scope && !*__eptr

  723. 	    && __val <= numeric_limits<scope_id_type>::max())

  724. 	  {

  725. 	    return { __b, static_cast<scope_id_type>(__val) };

  726. 	  }

  727. 	__ec = std::make_error_code(std::errc::invalid_argument);

  728.       }

  729.     else if (__res == 0)

  730.       __ec = std::make_error_code(std::errc::invalid_argument);

  731.     else

  732.       __ec.assign(errno, generic_category());

  733.     return {};

  734.   }

  735. 

  736.   inline address_v6

  737.   make_address_v6(const char* __str, error_code& __ec) noexcept

  738.   {

  739.     auto __p = __builtin_strchr(__str, '%');

  740.     if (__p == nullptr)

  741.       return __make_address_v6(__str, nullptr, __ec);

  742.     char __buf[64];

  743.     char* __out = __buf;

  744.     bool __skip_leading_zero = true;

  745.     while (__str < __p && __out < std::end(__buf))

  746.       {

  747. 	if (!__skip_leading_zero || *__str != '0')

  748. 	  {

  749. 	    if (*__str == ':' || *__str == '.')

  750. 	      __skip_leading_zero = true;

  751. 	    else

  752. 	      __skip_leading_zero = false;

  753. 	    *__out = *__str;

  754. 	  }

  755. 	__str++;

  756.       }

  757.     if (__out == std::end(__buf))

  758.       __ec = std::make_error_code(std::errc::invalid_argument);

  759.     else

  760.       {

  761. 	*__out = '\0';

  762. 	return __make_address_v6(__buf, __p + 1, __ec);

  763.       }

  764.   }

  765. 

  766.   inline address_v6

  767.   make_address_v6(const char* __str)

  768.   { return make_address_v6(__str, __throw_on_error{"make_address_v6"}); }

  769. 

  770.   inline address_v6

  771.   make_address_v6(const string& __str, error_code& __ec) noexcept

  772.   {

  773.     auto __pos = __str.find('%');

  774.     if (__pos == string::npos)

  775.       return __make_address_v6(__str.c_str(), nullptr, __ec);

  776.     char __buf[64];

  777.     char* __out = __buf;

  778.     bool __skip_leading_zero = true;

  779.     size_t __n = 0;

  780.     while (__n < __pos && __out < std::end(__buf))

  781.       {

  782. 	if (!__skip_leading_zero || __str[__n] != '0')

  783. 	  {

  784. 	    if (__str[__n] == ':' || __str[__n] == '.')

  785. 	      __skip_leading_zero = true;

  786. 	    else

  787. 	      __skip_leading_zero = false;

  788. 	    *__out = __str[__n];

  789. 	  }

  790. 	__n++;

  791.       }

  792.     if (__out == std::end(__buf))

  793.       __ec = std::make_error_code(std::errc::invalid_argument);

  794.     else

  795.       {

  796. 	*__out = '\0';

  797. 	return __make_address_v6(__buf, __str.c_str() + __pos + 1, __ec);

  798.       }

  799.   }

  800. 

  801.   inline address_v6

  802.   make_address_v6(const string& __str)

  803.   { return make_address_v6(__str, __throw_on_error{"make_address_v6"}); }

  804. 

  805.   inline address_v6

  806.   make_address_v6(string_view __str, error_code& __ec) noexcept

  807.   {

  808.     char __buf[64];

  809.     char* __out = __buf;

  810.     char* __scope = nullptr;

  811.     bool __skip_leading_zero = true;

  812.     size_t __n = 0;

  813.     while (__n < __str.length() && __out < std::end(__buf))

  814.       {

  815. 	if (__str[__n] == '%')

  816. 	  {

  817. 	    if (__scope)

  818. 	      __out = std::end(__buf);

  819. 	    else

  820. 	      {

  821. 		*__out = '\0';

  822. 		__scope = ++__out;

  823. 		__skip_leading_zero = true;

  824. 	      }

  825. 	  }

  826. 	else if (!__skip_leading_zero || __str[__n] != '0')

  827. 	  {

  828. 	    if (__str[__n] == ':' || __str[__n] == '.')

  829. 	      __skip_leading_zero = true;

  830. 	    else

  831. 	      __skip_leading_zero = false;

  832. 	    *__out = __str[__n];

  833. 	    __out++;

  834. 	  }

  835. 	__n++;

  836.       }

  837.     if (__out == std::end(__buf))

  838.       __ec = std::make_error_code(std::errc::invalid_argument);

  839.     else

  840.       {

  841. 	*__out = '\0';

  842. 	return __make_address_v6(__buf, __scope, __ec);

  843.       }

  844.   }

  845. 

  846.   inline address_v6

  847.   make_address_v6(string_view __str)

  848.   { return make_address_v6(__str, __throw_on_error{"make_address_v6"}); }

  849. 

  850.   // @}

  851. 

  852.   /** ip::address creation

  853.    * @{

  854.    */

  855. 

  856.   inline address

  857.   make_address(const char* __str, error_code& __ec) noexcept

  858.   {

  859.     address __a;

  860.     address_v6 __v6a = make_address_v6(__str, __ec);

  861.     if (!__ec)

  862.       __a = __v6a;

  863.     else

  864.     {

  865.       address_v4 __v4a = make_address_v4(__str, __ec);

  866.       if (!__ec)

  867. 	__a = __v4a;

  868.     }

  869.     return __a;

  870.   }

  871. 

  872.   inline address

  873.   make_address(const char* __str)

  874.   { return make_address(__str, __throw_on_error{"make_address"}); }

  875. 

  876.   inline address

  877.   make_address(const string& __str, error_code& __ec) noexcept; // TODO

  878. 

  879.   inline address

  880.   make_address(const string& __str)

  881.   { return make_address(__str, __throw_on_error{"make_address"}); }

  882. 

  883.   inline address

  884.   make_address(string_view __str, error_code& __ec) noexcept

  885.   {

  886.     if (__str.rfind('\0') != string_view::npos)

  887.       return make_address(__str.data(), __ec);

  888.     return make_address(__str.to_string(), __ec); // TODO don't allocate

  889.   }

  890. 

  891.   inline address

  892.   make_address(string_view __str)

  893.   { return make_address(__str, __throw_on_error{"make_address"}); }

  894. 

  895.   // @}

  896. 

  897.   /// ip::address I/O

  898.   template<typename _CharT, typename _Traits>

  899.     inline basic_ostream<_CharT, _Traits>&

  900.     operator<<(basic_ostream<_CharT, _Traits>& __os, const address& __a)

  901.     { return __os << __a.to_string(); }

  902. 

  903.   /// ip::address_v4 I/O

  904.   template<typename _CharT, typename _Traits>

  905.     inline basic_ostream<_CharT, _Traits>&

  906.     operator<<(basic_ostream<_CharT, _Traits>& __os, const address_v4& __a)

  907.     { return __os << __a.to_string(); }

  908. 

  909.   /// ip::address_v6 I/O

  910.   template<typename _CharT, typename _Traits>

  911.     inline basic_ostream<_CharT, _Traits>&

  912.     operator<<(basic_ostream<_CharT, _Traits>& __os, const address_v6& __a)

  913.     { return __os << __a.to_string(); }

  914. 

  915.   template<typename> class basic_address_iterator; // not defined

  916. 

  917.   template<> class basic_address_iterator<address_v4>

  918.   {

  919.   public:

  920.     // types:

  921.     typedef address_v4 value_type;

  922.     typedef ptrdiff_t difference_type;

  923.     typedef const address_v4* pointer;

  924.     typedef const address_v4& reference;

  925.     typedef input_iterator_tag iterator_category;

  926. 

  927.     // constructors:

  928.     basic_address_iterator(const address_v4& __a) noexcept

  929.     : _M_address(__a) { }

  930. 

  931.     // members:

  932.     reference operator*() const noexcept { return _M_address; }

  933.     pointer operator->() const noexcept { return &_M_address; }

  934. 

  935.     basic_address_iterator&

  936.     operator++() noexcept

  937.     {

  938.       _M_address = value_type(_M_address.to_uint() + 1);

  939.       return *this;

  940.     }

  941. 

  942.     basic_address_iterator operator++(int) noexcept

  943.     {

  944.       auto __tmp = *this;

  945.       ++*this;

  946.       return __tmp;

  947.     }

  948. 

  949.     basic_address_iterator& operator--() noexcept

  950.     {

  951.       _M_address = value_type(_M_address.to_uint() - 1);

  952.       return *this;

  953.     }

  954. 

  955.     basic_address_iterator

  956.     operator--(int) noexcept

  957.     {

  958.       auto __tmp = *this;

  959.       --*this;

  960.       return __tmp;

  961.     }

  962. 

  963.     bool

  964.     operator==(const basic_address_iterator& __rhs) const noexcept

  965.     { return _M_address == __rhs._M_address; }

  966. 

  967.     bool

  968.     operator!=(const basic_address_iterator& __rhs) const noexcept

  969.     { return _M_address != __rhs._M_address; }

  970. 

  971.   private:

  972.     address_v4 _M_address;

  973.   };

  974. 

  975.   typedef basic_address_iterator<address_v4> address_v4_iterator;

  976. 

  977.   template<> class basic_address_iterator<address_v6>

  978.   {

  979.   public:

  980.     // types:

  981.     typedef address_v6 value_type;

  982.     typedef ptrdiff_t difference_type;

  983.     typedef const address_v6* pointer;

  984.     typedef const address_v6& reference;

  985.     typedef input_iterator_tag iterator_category;

  986. 

  987.     // constructors:

  988.     basic_address_iterator(const address_v6& __a) noexcept

  989.     : _M_address(__a) { }

  990. 

  991.     // members:

  992.     reference operator*() const noexcept { return _M_address; }

  993.     pointer operator->() const noexcept { return &_M_address; }

  994. 

  995.     basic_address_iterator&

  996.     operator++() noexcept; // TODO

  997. 

  998.     basic_address_iterator

  999.     operator++(int) noexcept

  1000.     {

  1001.       auto __tmp = *this;

  1002.       ++*this;

  1003.       return __tmp;

  1004.     }

  1005. 

  1006.     basic_address_iterator&

  1007.     operator--() noexcept; // TODO

  1008. 

  1009.     basic_address_iterator

  1010.     operator--(int) noexcept

  1011.     {

  1012.       auto __tmp = *this;

  1013.       --*this;

  1014.       return __tmp;

  1015.     }

  1016. 

  1017.     bool

  1018.     operator==(const basic_address_iterator& __rhs) const noexcept

  1019.     { return _M_address == __rhs._M_address; }

  1020. 

  1021.     bool

  1022.     operator!=(const basic_address_iterator& __rhs) const noexcept

  1023.     { return _M_address != __rhs._M_address; }

  1024. 

  1025.   private:

  1026.     address_v6 _M_address;

  1027.   };

  1028. 

  1029.   typedef basic_address_iterator<address_v6> address_v6_iterator;

  1030. 

  1031.   template<typename> class basic_address_range; // not defined

  1032. 

  1033.   /** An IPv6 address range.

  1034.    * @{

  1035.    */

  1036. 

  1037.   template<> class basic_address_range<address_v4>

  1038.   {

  1039.   public:

  1040.     // types:

  1041. 

  1042.     typedef basic_address_iterator<address_v4> iterator;

  1043. 

  1044.     // constructors:

  1045. 

  1046.     basic_address_range() noexcept : _M_begin({}), _M_end({}) { }

  1047. 

  1048.     basic_address_range(const address_v4& __first,

  1049.                         const address_v4& __last) noexcept

  1050.     : _M_begin(__first), _M_end(__last) { }

  1051. 

  1052.     // members:

  1053. 

  1054.     iterator begin() const noexcept { return _M_begin; }

  1055.     iterator end() const noexcept { return _M_end; }

  1056.     _GLIBCXX_NODISCARD bool empty() const noexcept { return _M_begin == _M_end; }

  1057. 

  1058.     size_t

  1059.     size() const noexcept { return _M_end->to_uint() - _M_begin->to_uint(); }

  1060. 

  1061.     iterator

  1062.     find(const address_v4& __addr) const noexcept

  1063.     {

  1064.       if (*_M_begin <= __addr && __addr < *_M_end)

  1065. 	return iterator{__addr};

  1066.       return end();

  1067.     }

  1068. 

  1069.   private:

  1070.     iterator _M_begin;

  1071.     iterator _M_end;

  1072.   };

  1073. 

  1074.   typedef basic_address_range<address_v4> address_v4_range;

  1075. 

  1076.   // @}

  1077. 

  1078.   /** An IPv6 address range.

  1079.    * @{

  1080.    */

  1081. 

  1082.   template<> class basic_address_range<address_v6>

  1083.   {

  1084.   public:

  1085.     // types:

  1086. 

  1087.     typedef basic_address_iterator<address_v6> iterator;

  1088. 

  1089.     // constructors:

  1090. 

  1091.     basic_address_range() noexcept : _M_begin({}), _M_end({}) { }

  1092.     basic_address_range(const address_v6& __first,

  1093.                         const address_v6& __last) noexcept

  1094.     : _M_begin(__first), _M_end(__last) { }

  1095. 

  1096.     // members:

  1097. 

  1098.     iterator begin() const noexcept { return _M_begin; }

  1099.     iterator end() const noexcept { return _M_end; }

  1100.     _GLIBCXX_NODISCARD bool empty() const noexcept { return _M_begin == _M_end; }

  1101. 

  1102.     iterator

  1103.     find(const address_v6& __addr) const noexcept

  1104.     {

  1105.       if (*_M_begin <= __addr && __addr < *_M_end)

  1106. 	return iterator{__addr};

  1107.       return end();

  1108.     }

  1109. 

  1110.   private:

  1111.     iterator _M_begin;

  1112.     iterator _M_end;

  1113.   };

  1114. 

  1115.   typedef basic_address_range<address_v6> address_v6_range;

  1116. 

  1117.   // @}

  1118. 

  1119.   bool

  1120.   operator==(const network_v4& __a, const network_v4& __b) noexcept;

  1121. 

  1122.   bool

  1123.   operator==(const network_v6& __a, const network_v6& __b) noexcept;

  1124. 

  1125. 

  1126.   /// An IPv4 network address.

  1127.   class network_v4

  1128.   {

  1129.   public:

  1130.     // constructors:

  1131.     constexpr network_v4() noexcept : _M_addr(), _M_prefix_len(0) { }

  1132. 

  1133.     constexpr

  1134.     network_v4(const address_v4& __addr, int __prefix_len)

  1135.     : _M_addr(__addr), _M_prefix_len(__prefix_len)

  1136.     {

  1137.       if (_M_prefix_len < 0 || _M_prefix_len > 32)

  1138. 	__throw_out_of_range("network_v4: invalid prefix length");

  1139.     }

  1140. 

  1141.     constexpr

  1142.     network_v4(const address_v4& __addr, const address_v4& __mask)

  1143.     : _M_addr(__addr), _M_prefix_len(__builtin_popcount(__mask.to_uint()))

  1144.     {

  1145.       if (_M_prefix_len != 0)

  1146. 	{

  1147. 	  address_v4::uint_type __mask_uint = __mask.to_uint();

  1148. 	  if (__builtin_ctz(__mask_uint) != (32 - _M_prefix_len))

  1149. 	    __throw_invalid_argument("network_v4: invalid mask");

  1150. 	  if ((__mask_uint & 0x80000000) == 0)

  1151. 	    __throw_invalid_argument("network_v4: invalid mask");

  1152. 	}

  1153.     }

  1154. 

  1155.     // members:

  1156. 

  1157.     constexpr address_v4 address() const noexcept { return _M_addr; }

  1158.     constexpr int prefix_length() const noexcept { return _M_prefix_len; }

  1159. 

  1160.     constexpr address_v4

  1161.     netmask() const noexcept

  1162.     {

  1163.       address_v4::uint_type __val = address_v4::broadcast().to_uint();

  1164.       __val >>= (32 - _M_prefix_len);

  1165.       __val <<= (32 - _M_prefix_len);

  1166.       return address_v4{__val};

  1167.     }

  1168. 

  1169.     constexpr address_v4

  1170.     network() const noexcept

  1171.     { return address_v4{_M_addr.to_uint() & netmask().to_uint()}; }

  1172. 

  1173.     constexpr address_v4

  1174.     broadcast() const noexcept

  1175.     { return address_v4{_M_addr.to_uint() | ~netmask().to_uint()}; }

  1176. 

  1177.     address_v4_range

  1178.     hosts() const noexcept

  1179.     {

  1180.       if (is_host())

  1181. 	return { address(), *++address_v4_iterator(address()) };

  1182.       return { network(), broadcast() };

  1183.     }

  1184. 

  1185.     constexpr network_v4

  1186.     canonical() const noexcept

  1187.     { return network_v4(network(), prefix_length()); }

  1188. 

  1189.     constexpr bool is_host() const noexcept { return _M_prefix_len == 32; }

  1190. 

  1191.     constexpr bool

  1192.     is_subnet_of(const network_v4& __other) const noexcept

  1193.     {

  1194.       if (__other.prefix_length() < prefix_length())

  1195. 	{

  1196. 	  network_v4 __net(address(), __other.prefix_length());

  1197. 	  return __net.canonical() == __other.canonical();

  1198. 	}

  1199.       return false;

  1200.     }

  1201. 

  1202.     template<typename _Allocator = allocator<char>>

  1203.       __string_with<_Allocator>

  1204.       to_string(const _Allocator& __a = _Allocator()) const

  1205.       {

  1206. 	return address().to_string(__a) + '/'

  1207. 	  + std::to_string(prefix_length());

  1208.       }

  1209. 

  1210.   private:

  1211.     address_v4 _M_addr;

  1212.     int _M_prefix_len;

  1213.   };

  1214. 

  1215.   /// An IPv6 network address.

  1216.   class network_v6

  1217.   {

  1218.   public:

  1219.     // constructors:

  1220.     constexpr network_v6() noexcept : _M_addr(), _M_prefix_len(0) { }

  1221. 

  1222.     constexpr

  1223.     network_v6(const address_v6& __addr, int __prefix_len)

  1224.     : _M_addr(__addr), _M_prefix_len(__prefix_len)

  1225.     {

  1226.       if (_M_prefix_len < 0 || _M_prefix_len > 128)

  1227. 	__throw_out_of_range("network_v6: invalid prefix length");

  1228.     }

  1229. 

  1230.     // members:

  1231.     constexpr address_v6 address() const noexcept { return _M_addr; }

  1232.     constexpr int prefix_length() const noexcept { return _M_prefix_len; }

  1233. 

  1234.     constexpr address_v6 network() const noexcept; // TODO

  1235. 

  1236.     address_v6_range

  1237.     hosts() const noexcept

  1238.     {

  1239.       if (is_host())

  1240. 	return { address(), *++address_v6_iterator(address()) };

  1241.       return {}; // { network(), XXX broadcast() XXX }; // TODO

  1242.     }

  1243. 

  1244.     constexpr network_v6

  1245.     canonical() const noexcept

  1246.     { return network_v6{network(), prefix_length()}; }

  1247. 

  1248.     constexpr bool is_host() const noexcept { return _M_prefix_len == 128; }

  1249. 

  1250.     constexpr bool

  1251.     is_subnet_of(const network_v6& __other) const noexcept

  1252.     {

  1253.       if (__other.prefix_length() < prefix_length())

  1254. 	{

  1255. 	  network_v6 __net(address(), __other.prefix_length());

  1256. 	  return __net.canonical() == __other.canonical();

  1257. 	}

  1258.       return false;

  1259.     }

  1260. 

  1261.     template<typename _Allocator = allocator<char>>

  1262.       __string_with<_Allocator>

  1263.       to_string(const _Allocator& __a = _Allocator()) const

  1264.       {

  1265. 	return address().to_string(__a) + '/'

  1266. 	  + std::to_string(prefix_length());

  1267.       }

  1268. 

  1269.   private:

  1270.     address_v6 _M_addr;

  1271.     int _M_prefix_len;

  1272.   };

  1273. 

  1274. 

  1275.   /** ip::network_v4 comparisons

  1276.    * @{

  1277.    */

  1278. 

  1279.   inline bool

  1280.   operator==(const network_v4& __a, const network_v4& __b) noexcept

  1281.   {

  1282.     return __a.address() == __b.address()

  1283.       && __a.prefix_length() == __b.prefix_length();

  1284.   }

  1285. 

  1286.   inline bool

  1287.   operator!=(const network_v4& __a, const network_v4& __b) noexcept

  1288.   { return !(__a == __b); }

  1289. 

  1290.   // @}

  1291. 

  1292.   /** ip::network_v6 comparisons

  1293.    * @{

  1294.    */

  1295. 

  1296.   inline bool

  1297.   operator==(const network_v6& __a, const network_v6& __b) noexcept

  1298.   {

  1299.     return __a.address() == __b.address()

  1300.       && __a.prefix_length() == __b.prefix_length();

  1301.   }

  1302. 

  1303.   inline bool

  1304.   operator!=(const network_v6& __a, const network_v6& __b) noexcept

  1305.   { return !(__a == __b); }

  1306. 

  1307.   // @}

  1308. 

  1309.   /** ip::network_v4 creation

  1310.    * @{

  1311.    */

  1312. 

  1313.   inline network_v4

  1314.   make_network_v4(const address_v4& __a, int __prefix_len)

  1315.   { return network_v4{__a, __prefix_len}; }

  1316. 

  1317.   network_v4

  1318.   make_network_v4(const address_v4& __a, const address_v4& __mask)

  1319.   { return network_v4{ __a, __mask }; }

  1320. 

  1321.   network_v4 make_network_v4(const char*, error_code&) noexcept; // TODO

  1322. 

  1323.   inline network_v4

  1324.   make_network_v4(const char* __str)

  1325.   { return make_network_v4(__str, __throw_on_error{"make_network_v4"}); }

  1326. 

  1327.   network_v4 make_network_v4(const string&, error_code&) noexcept; // TODO

  1328. 

  1329.   inline network_v4

  1330.   make_network_v4(const string& __str)

  1331.   { return make_network_v4(__str, __throw_on_error{"make_network_v4"}); }

  1332. 

  1333.   network_v4 make_network_v4(string_view, error_code&) noexcept; // TODO

  1334. 

  1335.   inline network_v4

  1336.   make_network_v4(string_view __str)

  1337.   { return make_network_v4(__str, __throw_on_error{"make_network_v4"}); }

  1338. 

  1339.   // @}

  1340. 

  1341.   /** ip::network_v6 creation

  1342.    * @{

  1343.    */

  1344. 

  1345.   inline network_v6

  1346.   make_network_v6(const address_v6& __a, int __prefix_len)

  1347.   { return network_v6{__a, __prefix_len}; }

  1348. 

  1349.   network_v6 make_network_v6(const char*, error_code&) noexcept; // TODO

  1350. 

  1351.   inline network_v6

  1352.   make_network_v6(const char* __str)

  1353.   { return make_network_v6(__str, __throw_on_error{"make_network_v6"}); }

  1354. 

  1355.   network_v6 make_network_v6(const string&, error_code&) noexcept; // TODO

  1356. 

  1357.   inline network_v6

  1358.   make_network_v6(const string& __str)

  1359.   { return make_network_v6(__str, __throw_on_error{"make_network_v6"}); }

  1360. 

  1361.   network_v6 make_network_v6(string_view, error_code&) noexcept; // TODO

  1362. 

  1363.   inline network_v6

  1364.   make_network_v6(string_view __str)

  1365.   { return make_network_v6(__str, __throw_on_error{"make_network_v6"}); }

  1366. 

  1367.   // @}

  1368. 

  1369.   /// ip::network_v4 I/O

  1370.   template<typename _CharT, typename _Traits>

  1371.     inline basic_ostream<_CharT, _Traits>&

  1372.     operator<<(basic_ostream<_CharT, _Traits>& __os, const network_v4& __net)

  1373.     { return __os << __net.to_string(); }

  1374. 

  1375.   /// ip::network_v6 I/O

  1376.   template<typename _CharT, typename _Traits>

  1377.     inline basic_ostream<_CharT, _Traits>&

  1378.     operator<<(basic_ostream<_CharT, _Traits>& __os, const network_v6& __net)

  1379.     { return __os << __net.to_string(); }

  1380. 

  1381.   /// An IP endpoint.

  1382.   template<typename _InternetProtocol>

  1383.     class basic_endpoint

  1384.     {

  1385.     public:

  1386.       // types:

  1387.       typedef _InternetProtocol protocol_type;

  1388. 

  1389.       // constructors:

  1390. 

  1391.       constexpr

  1392.       basic_endpoint() noexcept : _M_data()

  1393.       { _M_data._M_v4.sin_family = protocol_type::v4().family(); }

  1394. 

  1395.       constexpr

  1396.       basic_endpoint(const protocol_type& __proto,

  1397. 		     port_type __port_num) noexcept

  1398.       : _M_data()

  1399.       {

  1400. 	__glibcxx_assert(__proto == protocol_type::v4()

  1401. 			  || __proto == protocol_type::v6());

  1402. 

  1403. 	_M_data._M_v4.sin_family = __proto.family();

  1404. 	_M_data._M_v4.sin_port = address_v4::_S_hton_16(__port_num);

  1405.       }

  1406. 

  1407.       constexpr

  1408.       basic_endpoint(const ip::address& __addr,

  1409. 		     port_type __port_num) noexcept

  1410.       : _M_data()

  1411.       {

  1412. 	if (__addr.is_v4())

  1413. 	  {

  1414. 	    _M_data._M_v4.sin_family = protocol_type::v4().family();

  1415. 	    _M_data._M_v4.sin_port = address_v4::_S_hton_16(__port_num);

  1416. 	    _M_data._M_v4.sin_addr.s_addr = __addr._M_v4._M_addr;

  1417. 	  }

  1418. 	else

  1419. 	  {

  1420. 	    _M_data._M_v6 = {};

  1421. 	    _M_data._M_v6.sin6_family = protocol_type::v6().family();

  1422. 	    _M_data._M_v6.sin6_port = address_v4::_S_hton_16(__port_num);

  1423. 	    __builtin_memcpy(_M_data._M_v6.sin6_addr.s6_addr,

  1424. 			     __addr._M_v6._M_bytes.data(), 16);

  1425. 	    _M_data._M_v6.sin6_scope_id = __addr._M_v6._M_scope_id;

  1426. 	  }

  1427.       }

  1428. 

  1429.       // members:

  1430.       constexpr protocol_type protocol() const noexcept

  1431.       {

  1432. 	return _M_data._M_v4.sin_family == AF_INET6

  1433. 	  ? protocol_type::v6() : protocol_type::v4();

  1434.       }

  1435. 

  1436.       constexpr ip::address

  1437.       address() const noexcept

  1438.       {

  1439. 	ip::address __addr;

  1440. 	if (protocol().family() == AF_INET6)

  1441. 	  {

  1442. 	    __builtin_memcpy(&__addr._M_v6._M_bytes,

  1443. 			     _M_data._M_v6.sin6_addr.s6_addr, 16);

  1444. 	    __addr._M_is_v4 = false;

  1445. 	  }

  1446. 	else

  1447. 	  {

  1448. 	    __builtin_memcpy(&__addr._M_v4._M_addr,

  1449. 			     &_M_data._M_v4.sin_addr.s_addr, 4);

  1450. 	  }

  1451. 	return __addr;

  1452.       }

  1453. 

  1454.       void

  1455.       address(const ip::address& __addr) noexcept

  1456.       {

  1457. 	if (__addr.is_v6())

  1458. 	  {

  1459. 	    _M_data._M_v6 = {};

  1460. 	    _M_data._M_v6.sin6_family = protocol_type::v6().family();

  1461. 	    __builtin_memcpy(_M_data._M_v6.sin6_addr.s6_addr,

  1462. 			     __addr._M_v6._M_bytes.data(), 16);

  1463. 	    _M_data._M_v6.sin6_scope_id = __addr._M_v6._M_scope_id;

  1464. 	  }

  1465. 	else

  1466. 	  {

  1467. 	    _M_data._M_v4.sin_family = protocol_type::v4().family();

  1468. 	    _M_data._M_v4.sin_addr.s_addr = __addr._M_v4._M_addr;

  1469. 	  }

  1470.       }

  1471. 

  1472.       constexpr port_type

  1473.       port() const noexcept

  1474.       { return address_v4::_S_ntoh_16(_M_data._M_v4.sin_port); }

  1475. 

  1476.       void

  1477.       port(port_type __port_num) noexcept

  1478.       { _M_data._M_v4.sin_port = address_v4::_S_hton_16(__port_num); }

  1479. 

  1480.       void* data() noexcept { return &_M_data; }

  1481.       const void* data() const noexcept { return &_M_data; }

  1482.       constexpr size_t size() const noexcept

  1483.       {

  1484. 	return protocol().family() == AF_INET6

  1485. 	  ? sizeof(sockaddr_in6) : sizeof(sockaddr_in);

  1486.       }

  1487. 

  1488.       void

  1489.       resize(size_t __s)

  1490.       {

  1491. 	if ((protocol().family() == AF_INET6 && __s != sizeof(sockaddr_in6))

  1492. 	    || (protocol().family() == AF_INET && __s != sizeof(sockaddr_in)))

  1493. 	  __throw_length_error("net::ip::basic_endpoint::resize");

  1494.       }

  1495. 

  1496.       constexpr size_t capacity() const noexcept { return sizeof(_M_data); }

  1497. 

  1498.     private:

  1499.       union

  1500.       {

  1501. 	sockaddr_in	_M_v4;

  1502. 	sockaddr_in6	_M_v6;

  1503.       } _M_data;

  1504.     };

  1505. 

  1506.   /** basic_endpoint comparisons

  1507.    * @{

  1508.    */

  1509. 

  1510.   template<typename _InternetProtocol>

  1511.     inline bool

  1512.     operator==(const basic_endpoint<_InternetProtocol>& __a,

  1513. 	       const basic_endpoint<_InternetProtocol>& __b)

  1514.     { return __a.address() == __b.address() && __a.port() == __b.port(); }

  1515. 

  1516.   template<typename _InternetProtocol>

  1517.     inline bool

  1518.     operator!=(const basic_endpoint<_InternetProtocol>& __a,

  1519. 	       const basic_endpoint<_InternetProtocol>& __b)

  1520.     { return !(__a == __b); }

  1521. 

  1522.   template<typename _InternetProtocol>

  1523.     inline bool

  1524.     operator< (const basic_endpoint<_InternetProtocol>& __a,

  1525. 	       const basic_endpoint<_InternetProtocol>& __b)

  1526.     {

  1527.       return __a.address() < __b.address()

  1528. 	|| (!(__b.address() < __a.address()) && __a.port() < __b.port());

  1529.     }

  1530. 

  1531.   template<typename _InternetProtocol>

  1532.     inline bool

  1533.     operator> (const basic_endpoint<_InternetProtocol>& __a,

  1534. 	       const basic_endpoint<_InternetProtocol>& __b)

  1535.     { return __b < __a; }

  1536. 

  1537.   template<typename _InternetProtocol>

  1538.     inline bool

  1539.     operator<=(const basic_endpoint<_InternetProtocol>& __a,

  1540. 	       const basic_endpoint<_InternetProtocol>& __b)

  1541.     { return !(__b < __a); }

  1542. 

  1543.   template<typename _InternetProtocol>

  1544.     inline bool

  1545.     operator>=(const basic_endpoint<_InternetProtocol>& __a,

  1546. 	       const basic_endpoint<_InternetProtocol>& __b)

  1547.     { return !(__a < __b); }

  1548. 

  1549.   // @}

  1550. 

  1551.   /// basic_endpoint I/O

  1552.   template<typename _CharT, typename _Traits, typename _InternetProtocol>

  1553.     inline basic_ostream<_CharT, _Traits>&

  1554.     operator<<(basic_ostream<_CharT, _Traits>& __os,

  1555. 	       const basic_endpoint<_InternetProtocol>& __ep)

  1556.     {

  1557.       basic_ostringstream<_CharT, _Traits> __ss;

  1558.       if (__ep.protocol()

  1559. 	  == basic_endpoint<_InternetProtocol>::protocol_type::v6())

  1560. 	__ss << '[' << __ep.address() << ']';

  1561.       else

  1562. 	__ss << __ep.address();

  1563.       __ss << ':' << __ep.port();

  1564.       __os << __ss.str();

  1565.       return __os;

  1566.     }

  1567. 

  1568.   /** Type representing a single result of name/address resolution.

  1569.    * @{

  1570.    */

  1571. 

  1572.   template<typename _InternetProtocol>

  1573.     class basic_resolver_entry

  1574.     {

  1575.     public:

  1576.       // types:

  1577.       typedef _InternetProtocol protocol_type;

  1578.       typedef typename _InternetProtocol::endpoint endpoint_type;

  1579. 

  1580.       // constructors:

  1581.       basic_resolver_entry() { }

  1582. 

  1583.       basic_resolver_entry(const endpoint_type& __ep,

  1584. 			   string_view __h, string_view __s)

  1585.       : _M_ep(__ep), _M_host(__h), _M_svc(__s) { }

  1586. 

  1587.       // members:

  1588.       endpoint_type endpoint() const { return _M_ep; }

  1589.       operator endpoint_type() const { return _M_ep; }

  1590. 

  1591.       template<typename _Allocator = allocator<char>>

  1592. 	__string_with<_Allocator>

  1593. 	host_name(const _Allocator& __a = _Allocator()) const

  1594. 	{ return { _M_host, __a }; }

  1595. 

  1596.       template<typename _Allocator = allocator<char>>

  1597. 	__string_with<_Allocator>

  1598. 	service_name(const _Allocator& __a = _Allocator()) const

  1599. 	{ return { _M_svc, __a }; }

  1600. 

  1601.     private:

  1602.       basic_endpoint<_InternetProtocol> _M_ep;

  1603.       string _M_host;

  1604.       string _M_svc;

  1605.     };

  1606. 

  1607.   template<typename _InternetProtocol>

  1608.     inline bool

  1609.     operator==(const basic_resolver_entry<_InternetProtocol>& __a,

  1610. 	       const basic_resolver_entry<_InternetProtocol>& __b)

  1611.     {

  1612.       return __a.endpoint() == __b.endpoint()

  1613. 	&& __a.host_name() == __b.host_name()

  1614. 	&& __a.service_name() == __b.service_name();

  1615.     }

  1616. 

  1617.   template<typename _InternetProtocol>

  1618.     inline bool

  1619.     operator!=(const basic_resolver_entry<_InternetProtocol>& __a,

  1620. 	       const basic_resolver_entry<_InternetProtocol>& __b)

  1621.     { return !(__a == __b); }

  1622. 

  1623.   // @}

  1624. 

  1625.   /** Base class defining flags for name/address resolution.

  1626.    * @{

  1627.    */

  1628. 

  1629.   class resolver_base

  1630.   {

  1631.   public:

  1632.     enum flags : int

  1633.     {

  1634.       __flags_passive			= AI_PASSIVE,

  1635.       __flags_canonical_name		= AI_CANONNAME,

  1636.       __flags_numeric_host		= AI_NUMERICHOST,

  1637. #ifdef AI_NUMERICSERV

  1638.       __flags_numeric_service		= AI_NUMERICSERV,

  1639. #endif

  1640.       __flags_v4_mapped			= AI_V4MAPPED,

  1641.       __flags_all_matching		= AI_ALL,

  1642.       __flags_address_configured	= AI_ADDRCONFIG

  1643.     };

  1644.     static constexpr flags passive		= __flags_passive;

  1645.     static constexpr flags canonical_name	= __flags_canonical_name;

  1646.     static constexpr flags numeric_host		= __flags_numeric_host;

  1647. #ifdef AI_NUMERICSERV

  1648.     static constexpr flags numeric_service	= __flags_numeric_service;

  1649. #endif

  1650.     static constexpr flags v4_mapped		= __flags_v4_mapped;

  1651.     static constexpr flags all_matching		= __flags_all_matching;

  1652.     static constexpr flags address_configured	= __flags_address_configured;

  1653. 

  1654.   protected:

  1655.     resolver_base() = default;

  1656.     ~resolver_base() = default;

  1657.   };

  1658. 

  1659.   constexpr resolver_base::flags

  1660.   operator&(resolver_base::flags __f1, resolver_base::flags __f2)

  1661.   { return resolver_base::flags( int(__f1) & int(__f2) ); }

  1662. 

  1663.   constexpr resolver_base::flags

  1664.   operator|(resolver_base::flags __f1, resolver_base::flags __f2)

  1665.   { return resolver_base::flags( int(__f1) | int(__f2) ); }

  1666. 

  1667.   constexpr resolver_base::flags

  1668.   operator^(resolver_base::flags __f1, resolver_base::flags __f2)

  1669.   { return resolver_base::flags( int(__f1) ^ int(__f2) ); }

  1670. 

  1671.   constexpr resolver_base::flags

  1672.   operator~(resolver_base::flags __f)

  1673.   { return resolver_base::flags( ~int(__f) ); }

  1674. 

  1675.   inline resolver_base::flags&

  1676.   operator&=(resolver_base::flags& __f1, resolver_base::flags __f2)

  1677.   { return __f1 = (__f1 & __f2); }

  1678. 

  1679.   inline resolver_base::flags&

  1680.   operator|=(resolver_base::flags& __f1, resolver_base::flags __f2)

  1681.   { return __f1 = (__f1 | __f2); }

  1682. 

  1683.   inline resolver_base::flags&

  1684.   operator^=(resolver_base::flags& __f1, resolver_base::flags __f2)

  1685.   { return __f1 = (__f1 ^ __f2); }

  1686. 

  1687.   // TODO define resolver_base::flags static constants for C++14 mode

  1688. 

  1689.   // @}

  1690. 

  1691.   /** Container for results of name/address resolution.

  1692.    * @{

  1693.    */

  1694. 

  1695.   template<typename _InternetProtocol>

  1696.     class basic_resolver_results

  1697.     {

  1698.     public:

  1699.       // types:

  1700.       typedef _InternetProtocol protocol_type;

  1701.       typedef typename protocol_type::endpoint endpoint_type;

  1702.       typedef basic_resolver_entry<protocol_type> value_type;

  1703.       typedef const value_type& const_reference;

  1704.       typedef value_type& reference;

  1705.       typedef typename forward_list<value_type>::const_iterator const_iterator;

  1706.       typedef const_iterator iterator;

  1707.       typedef ptrdiff_t difference_type;

  1708.       typedef size_t size_type;

  1709. 

  1710.       // construct / copy / destroy:

  1711. 

  1712.       basic_resolver_results() = default;

  1713. 

  1714.       basic_resolver_results(const basic_resolver_results&) = default;

  1715. 

  1716.       basic_resolver_results(basic_resolver_results&&) noexcept = default;

  1717. 

  1718.       basic_resolver_results&

  1719.       operator=(const basic_resolver_results&) = default;

  1720. 

  1721.       basic_resolver_results&

  1722.       operator=(basic_resolver_results&&) = default;

  1723. 

  1724.       ~basic_resolver_results() = default;

  1725. 

  1726.       // size:

  1727.       size_type size() const noexcept { return _M_size; }

  1728.       size_type max_size() const noexcept { return _M_results.max_size(); }

  1729. 

  1730.       _GLIBCXX_NODISCARD bool

  1731.       empty() const noexcept { return _M_results.empty(); }

  1732. 

  1733.       // element access:

  1734.       const_iterator begin() const { return _M_results.begin(); }

  1735.       const_iterator end() const { return _M_results.end(); }

  1736.       const_iterator cbegin() const { return _M_results.begin(); }

  1737.       const_iterator cend() const { return _M_results.end(); }

  1738. 

  1739.       // swap:

  1740.       void

  1741.       swap(basic_resolver_results& __that) noexcept

  1742.       { _M_results.swap(__that._M_results); }

  1743. 

  1744.     private:

  1745.       friend class basic_resolver<protocol_type>;

  1746. 

  1747.       basic_resolver_results(string_view, string_view, resolver_base::flags,

  1748. 			     error_code&, protocol_type* = nullptr);

  1749. 

  1750.       basic_resolver_results(const endpoint_type&, error_code&);

  1751. 

  1752.       forward_list<value_type> _M_results;

  1753.       size_t _M_size = 0;

  1754.     };

  1755. 

  1756.   template<typename _InternetProtocol>

  1757.     inline bool

  1758.     operator==(const basic_resolver_results<_InternetProtocol>& __a,

  1759. 	       const basic_resolver_results<_InternetProtocol>& __b)

  1760.     {

  1761.       return __a.size() == __b.size()

  1762. 	&& std::equal(__a.begin(), __a.end(), __b.begin());

  1763.     }

  1764. 

  1765.   template<typename _InternetProtocol>

  1766.     inline bool

  1767.     operator!=(const basic_resolver_results<_InternetProtocol>& __a,

  1768. 	       const basic_resolver_results<_InternetProtocol>& __b)

  1769.     { return !(__a == __b); }

  1770. 

  1771.   // @}

  1772. 

  1773.   /// Perform name/address resolution.

  1774.   template<typename _InternetProtocol>

  1775.     class basic_resolver : public resolver_base

  1776.     {

  1777.     public:

  1778.       // types:

  1779. 

  1780.       typedef io_context::executor_type executor_type;

  1781.       typedef _InternetProtocol protocol_type;

  1782.       typedef typename _InternetProtocol::endpoint endpoint_type;

  1783.       typedef basic_resolver_results<_InternetProtocol> results_type;

  1784. 

  1785.       // construct / copy / destroy:

  1786. 

  1787.       explicit basic_resolver(io_context& __ctx) : _M_ctx(&__ctx) { }

  1788. 

  1789.       basic_resolver(const basic_resolver&) = delete;

  1790. 

  1791.       basic_resolver(basic_resolver&& __rhs) noexcept

  1792.       : _M_ctx(__rhs._M_ctx)

  1793.       { } // TODO move state/tasks etc.

  1794. 

  1795.       ~basic_resolver() { cancel(); }

  1796. 

  1797.       basic_resolver& operator=(const basic_resolver&) = delete;

  1798. 

  1799.       basic_resolver& operator=(basic_resolver&& __rhs)

  1800.       {

  1801. 	cancel();

  1802. 	_M_ctx = __rhs._M_ctx;

  1803. 	// TODO move state/tasks etc.

  1804. 	return *this;

  1805.       }

  1806. 

  1807.       // basic_resolver operations:

  1808. 

  1809.       executor_type get_executor() noexcept { return _M_ctx->get_executor(); }

  1810. 

  1811.       void cancel() { } // TODO

  1812. 

  1813.       results_type

  1814.       resolve(string_view __host_name, string_view __service_name)

  1815.       {

  1816. 	return resolve(__host_name, __service_name, resolver_base::flags(),

  1817. 		       __throw_on_error{"basic_resolver::resolve"});

  1818.       }

  1819. 

  1820.       results_type

  1821.       resolve(string_view __host_name, string_view __service_name,

  1822. 	      error_code& __ec)

  1823.       {

  1824. 	return resolve(__host_name, __service_name, resolver_base::flags(),

  1825. 		       __ec);

  1826.       }

  1827. 

  1828.       results_type

  1829.       resolve(string_view __host_name, string_view __service_name, flags __f)

  1830.       {

  1831. 	return resolve(__host_name, __service_name, __f,

  1832. 		       __throw_on_error{"basic_resolver::resolve"});

  1833.       }

  1834. 

  1835.       results_type

  1836.       resolve(string_view __host_name, string_view __service_name, flags __f,

  1837. 	      error_code& __ec)

  1838.       { return {__host_name, __service_name, __f, __ec}; }

  1839. 

  1840.       template<typename _CompletionToken>

  1841. 	__deduced_t<_CompletionToken, void(error_code, results_type)>

  1842. 	async_resolve(string_view __host_name, string_view __service_name,

  1843. 		      _CompletionToken&& __token)

  1844. 	{

  1845. 	  return async_resolve(__host_name, __service_name,

  1846. 			       resolver_base::flags(),

  1847. 			       forward<_CompletionToken>(__token));

  1848. 	}

  1849. 

  1850.       template<typename _CompletionToken>

  1851. 	__deduced_t<_CompletionToken, void(error_code, results_type)>

  1852. 	async_resolve(string_view __host_name, string_view __service_name,

  1853. 		      flags __f, _CompletionToken&& __token); // TODO

  1854. 

  1855.       results_type

  1856.       resolve(const protocol_type& __protocol,

  1857. 	      string_view __host_name, string_view __service_name)

  1858.       {

  1859. 	return resolve(__protocol, __host_name, __service_name,

  1860. 		       resolver_base::flags(),

  1861. 		       __throw_on_error{"basic_resolver::resolve"});

  1862.       }

  1863. 

  1864.       results_type

  1865.       resolve(const protocol_type& __protocol,

  1866. 	      string_view __host_name, string_view __service_name,

  1867. 	      error_code& __ec)

  1868.       {

  1869. 	return resolve(__protocol, __host_name, __service_name,

  1870. 		       resolver_base::flags(), __ec);

  1871.       }

  1872. 

  1873.       results_type

  1874.       resolve(const protocol_type& __protocol,

  1875. 	      string_view __host_name, string_view __service_name, flags __f)

  1876.       {

  1877. 	return resolve(__protocol, __host_name, __service_name, __f,

  1878. 		       __throw_on_error{"basic_resolver::resolve"});

  1879.       }

  1880. 

  1881.       results_type

  1882.       resolve(const protocol_type& __protocol,

  1883. 	      string_view __host_name, string_view __service_name,

  1884. 	      flags __f, error_code& __ec)

  1885.       { return {__host_name, __service_name, __f, __ec, &__protocol}; }

  1886. 

  1887.       template<typename _CompletionToken>

  1888. 	__deduced_t<_CompletionToken, void(error_code, results_type)>

  1889. 	async_resolve(const protocol_type& __protocol,

  1890. 		      string_view __host_name, string_view __service_name,

  1891. 		      _CompletionToken&& __token)

  1892. 	{

  1893. 	  return async_resolve(__protocol, __host_name, __service_name,

  1894. 			       resolver_base::flags(),

  1895. 			       forward<_CompletionToken>(__token));

  1896. 	}

  1897. 

  1898.       template<typename _CompletionToken>

  1899. 	__deduced_t<_CompletionToken, void(error_code, results_type)>

  1900. 	async_resolve(const protocol_type& __protocol,

  1901. 		      string_view __host_name, string_view __service_name,

  1902. 		      flags __f, _CompletionToken&& __token); // TODO

  1903. 

  1904.       results_type

  1905.       resolve(const endpoint_type& __ep)

  1906.       { return resolve(__ep, __throw_on_error{"basic_resolver::resolve"}); }

  1907. 

  1908.       results_type

  1909.       resolve(const endpoint_type& __ep, error_code& __ec)

  1910.       { return { __ep, __ec }; }

  1911. 

  1912.       template<typename _CompletionToken> // TODO

  1913. 	__deduced_t<_CompletionToken, void(error_code, results_type)>

  1914. 	async_resolve(const endpoint_type& __ep, _CompletionToken&& __token);

  1915. 

  1916.     private:

  1917.       io_context* _M_ctx;

  1918.     };

  1919. 

  1920.   /// Private constructor to synchronously resolve host and service names.

  1921.   template<typename _InternetProtocol>

  1922.     basic_resolver_results<_InternetProtocol>::

  1923.     basic_resolver_results(string_view __host_name, string_view __service_name,

  1924. 			   resolver_base::flags __f, error_code& __ec,

  1925. 			   protocol_type* __protocol)

  1926.     {

  1927. #ifdef _GLIBCXX_HAVE_NETDB_H

  1928.       string __host;

  1929.       const char* __h = __host_name.data()

  1930. 	? (__host = __host_name.to_string()).c_str()

  1931. 	: nullptr;

  1932.       string __svc;

  1933.       const char* __s = __service_name.data()

  1934. 	? (__svc = __service_name.to_string()).c_str()

  1935. 	: nullptr;

  1936. 

  1937.       ::addrinfo __hints{ };

  1938.       __hints.ai_flags = static_cast<int>(__f);

  1939.       if (__protocol)

  1940. 	{

  1941. 	  __hints.ai_family = __protocol->family();

  1942. 	  __hints.ai_socktype = __protocol->type();

  1943. 	  __hints.ai_protocol = __protocol->protocol();

  1944. 	}

  1945.       else

  1946. 	{

  1947. 	  auto __p = endpoint_type{}.protocol();

  1948. 	  __hints.ai_family = AF_UNSPEC;

  1949. 	  __hints.ai_socktype = __p.type();

  1950. 	  __hints.ai_protocol = __p.protocol();

  1951. 	}

  1952. 

  1953.       struct __scoped_addrinfo

  1954.       {

  1955. 	~__scoped_addrinfo() { if (_M_p) ::freeaddrinfo(_M_p); }

  1956. 	::addrinfo* _M_p = nullptr;

  1957.       } __sai;

  1958. 

  1959.       if (int __err = ::getaddrinfo(__h, __s, &__hints, &__sai._M_p))

  1960. 	{

  1961. 	  __ec.assign(__err, resolver_category());

  1962. 	  return;

  1963. 	}

  1964.       __ec.clear();

  1965. 

  1966.       endpoint_type __ep;

  1967.       auto __tail = _M_results.before_begin();

  1968.       for (auto __ai = __sai._M_p; __ai != nullptr; __ai = __ai->ai_next)

  1969. 	{

  1970. 	  if (__ai->ai_family == AF_INET || __ai->ai_family == AF_INET6)

  1971. 	    {

  1972. 	      if (__ai->ai_addrlen <= __ep.capacity())

  1973. 		__builtin_memcpy(__ep.data(), __ai->ai_addr, __ai->ai_addrlen);

  1974. 	      __ep.resize(__ai->ai_addrlen);

  1975. 	      __tail = _M_results.emplace_after(__tail, __ep, __host, __svc);

  1976. 	      _M_size++;

  1977. 	    }

  1978. 	}

  1979. #else

  1980.       __ec = std::make_error_code(errc::operation_not_supported);

  1981. #endif

  1982.     }

  1983. 

  1984.   /// Private constructor to synchronously resolve an endpoint.

  1985.   template<typename _InternetProtocol>

  1986.     basic_resolver_results<_InternetProtocol>::

  1987.     basic_resolver_results(const endpoint_type& __ep, error_code& __ec)

  1988.     {

  1989. #ifdef _GLIBCXX_HAVE_NETDB_H

  1990.       char __host_name[256];

  1991.       char __service_name[128];

  1992.       int __flags = 0;

  1993.       if (__ep.protocol().type() == SOCK_DGRAM)

  1994. 	__flags |= NI_DGRAM;

  1995.       auto __sa = static_cast<const sockaddr*>(__ep.data());

  1996.       int __err = ::getnameinfo(__sa, __ep.size(),

  1997. 				__host_name, sizeof(__host_name),

  1998. 				__service_name, sizeof(__service_name),

  1999. 				__flags);

  2000.       if (__err)

  2001. 	{

  2002. 	  __flags |= NI_NUMERICSERV;

  2003. 	  __err = ::getnameinfo(__sa, __ep.size(),

  2004. 				__host_name, sizeof(__host_name),

  2005. 				__service_name, sizeof(__service_name),

  2006. 				__flags);

  2007. 	}

  2008.       if (__err)

  2009. 	__ec.assign(__err, resolver_category());

  2010.       else

  2011. 	{

  2012. 	  __ec.clear();

  2013. 	  _M_results.emplace_front(__ep, __host_name, __service_name);

  2014. 	  _M_size = 1;

  2015. 	}

  2016. #else

  2017.       __ec = std::make_error_code(errc::operation_not_supported);

  2018. #endif

  2019.     }

  2020. 

  2021.   /** The name of the local host.

  2022.    * @{

  2023.    */

  2024. 

  2025.   template<typename _Allocator>

  2026.     __string_with<_Allocator>

  2027.     host_name(const _Allocator& __a, error_code& __ec)

  2028.     {

  2029. #ifdef HOST_NAME_MAX

  2030.       constexpr size_t __maxlen = HOST_NAME_MAX;

  2031. #else

  2032.       constexpr size_t __maxlen = 256;

  2033. #endif

  2034.       char __buf[__maxlen + 1];

  2035.       if (::gethostname(__buf, __maxlen) == -1)

  2036. 	__ec.assign(errno, generic_category());

  2037.       __buf[__maxlen] = '\0';

  2038.       return { __buf, __a };

  2039.     }

  2040. 

  2041.   template<typename _Allocator>

  2042.     inline __string_with<_Allocator>

  2043.     host_name(const _Allocator& __a)

  2044.     { return host_name(__a, __throw_on_error{"host_name"}); }

  2045. 

  2046.   inline string

  2047.   host_name(error_code& __ec)

  2048.   { return host_name(std::allocator<char>{}, __ec); }

  2049. 

  2050.   inline string

  2051.   host_name()

  2052.   { return host_name(std::allocator<char>{}, __throw_on_error{"host_name"}); }

  2053. 

  2054.   // @}

  2055. 

  2056.   /// The TCP byte-stream protocol.

  2057.   class tcp

  2058.   {

  2059.   public:

  2060.     // types:

  2061.     typedef basic_endpoint<tcp> endpoint;	 ///< A TCP endpoint.

  2062.     typedef basic_resolver<tcp> resolver;	 ///< A TCP resolver.

  2063.     typedef basic_stream_socket<tcp> socket;	 ///< A TCP socket.

  2064.     typedef basic_socket_acceptor<tcp> acceptor; ///< A TCP acceptor.

  2065.     typedef basic_socket_iostream<tcp> iostream; /// A TCP iostream.

  2066. 

  2067. #ifdef _GLIBCXX_HAVE_NETINET_TCP_H

  2068.     /// Disable coalescing of small segments (i.e. the Nagle algorithm).

  2069.     struct no_delay : __sockopt_crtp<no_delay, bool>

  2070.     {

  2071.       using __sockopt_crtp::__sockopt_crtp;

  2072. 

  2073.       static const int _S_level = IPPROTO_TCP;

  2074.       static const int _S_name = TCP_NODELAY;

  2075.     };

  2076. #endif

  2077. 

  2078.     // static members:

  2079. 

  2080.     /// A protocol object representing IPv4 TCP.

  2081.     static constexpr tcp v4() noexcept { return tcp(AF_INET); }

  2082.     /// A protocol object representing IPv6 TCP.

  2083.     static constexpr tcp v6() noexcept { return tcp(AF_INET6); }

  2084. 

  2085.     tcp() = delete;

  2086. 

  2087.     constexpr int family() const noexcept { return _M_family; }

  2088.     constexpr int type() const noexcept { return SOCK_STREAM; }

  2089.     constexpr int protocol() const noexcept { return IPPROTO_TCP; }

  2090. 

  2091.   private:

  2092.     constexpr explicit tcp(int __family) : _M_family(__family) { }

  2093. 

  2094.     int _M_family;

  2095.   };

  2096. 

  2097.   /** tcp comparisons

  2098.    * @{

  2099.    */

  2100. 

  2101.   inline bool

  2102.   operator==(const tcp& __a, const tcp& __b)

  2103.   { return __a.family() == __b.family(); }

  2104. 

  2105.   inline bool

  2106.   operator!=(const tcp& __a, const tcp& __b)

  2107.   { return !(__a == __b); }

  2108. 

  2109.   // @}

  2110. 

  2111.   /// The UDP datagram protocol.

  2112.   class udp

  2113.   {

  2114.   public:

  2115.     // types:

  2116.     typedef basic_endpoint<udp> endpoint;

  2117.     typedef basic_resolver<udp> resolver;

  2118.     typedef basic_datagram_socket<udp> socket;

  2119. 

  2120.     // static members:

  2121.     static constexpr udp v4() noexcept { return udp(AF_INET); }

  2122.     static constexpr udp v6() noexcept { return udp(AF_INET6); }

  2123. 

  2124.     udp() = delete;

  2125. 

  2126.     constexpr int family() const noexcept { return _M_family; }

  2127.     constexpr int type() const noexcept { return SOCK_DGRAM; }

  2128.     constexpr int protocol() const noexcept { return IPPROTO_UDP; }

  2129. 

  2130.   private:

  2131.     constexpr explicit udp(int __family) : _M_family(__family) { }

  2132. 

  2133.     int _M_family;

  2134.   };

  2135. 

  2136.   /** udp comparisons

  2137.    * @{

  2138.    */

  2139. 

  2140.   bool

  2141.   operator==(const udp& __a, const udp& __b)

  2142.   { return __a.family() == __b.family(); }

  2143. 

  2144.   inline bool

  2145.   operator!=(const udp& __a, const udp& __b)

  2146.   { return !(__a == __b); }

  2147. 

  2148.   // @}

  2149. 

  2150.   /// Restrict a socket created for an IPv6 protocol to IPv6 only.

  2151.   struct v6_only : __sockopt_crtp<v6_only, bool>

  2152.   {

  2153.     using __sockopt_crtp::__sockopt_crtp;

  2154. 

  2155.     static const int _S_level = IPPROTO_IPV6;

  2156.     static const int _S_name = IPV6_V6ONLY;

  2157.   };

  2158. 

  2159.   namespace unicast

  2160.   {

  2161.     /// Set the default number of hops (TTL) for outbound datagrams.

  2162.     struct hops : __sockopt_crtp<hops>

  2163.     {

  2164.       using __sockopt_crtp::__sockopt_crtp;

  2165. 

  2166.       template<typename _Protocol>

  2167. 	int

  2168. 	level(const _Protocol& __p) const noexcept

  2169. 	{ return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; }

  2170. 

  2171.       template<typename _Protocol>

  2172. 	int

  2173. 	name(const _Protocol& __p) const noexcept

  2174. 	{ return __p.family() == AF_INET6 ? IPV6_UNICAST_HOPS : IP_TTL; }

  2175.     };

  2176.   } // namespace unicast

  2177. 

  2178.   namespace multicast

  2179.   {

  2180.     /// Request that a socket joins a multicast group.

  2181.     struct join_group

  2182.     {

  2183.       explicit

  2184.       join_group(const address&);

  2185. 

  2186.       explicit

  2187.       join_group(const address_v4&, const address_v4& = address_v4::any());

  2188. 

  2189.       explicit

  2190.       join_group(const address_v6&, unsigned int = 0);

  2191. 

  2192.       template<typename _Protocol>

  2193. 	int

  2194. 	level(const _Protocol& __p) const noexcept

  2195. 	{ return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; }

  2196. 

  2197.       template<typename _Protocol>

  2198. 	int

  2199. 	name(const _Protocol& __p) const noexcept

  2200. 	{

  2201. 	  return __p.family() == AF_INET6

  2202. 	    ? IPV6_JOIN_GROUP : IP_ADD_MEMBERSHIP;

  2203. 	}

  2204.       template<typename _Protocol>

  2205. 	void*

  2206. 	data(const _Protocol&) noexcept

  2207. 	{ return std::addressof(_M_value); }

  2208. 

  2209.       template<typename _Protocol>

  2210. 	const void*

  2211. 	data(const _Protocol&) const noexcept

  2212. 	{ return std::addressof(_M_value); }

  2213. 

  2214.       template<typename _Protocol>

  2215. 	size_t

  2216. 	size(const _Protocol& __p) const noexcept

  2217. 	{

  2218. 	  return __p.family() == AF_INET6

  2219. 	    ? sizeof(_M_value._M_v6) : sizeof(_M_value._M_v4);

  2220. 	}

  2221. 

  2222.       template<typename _Protocol>

  2223. 	void

  2224. 	resize(const _Protocol& __p, size_t __s)

  2225. 	{

  2226. 	  if (__s != size(__p))

  2227. 	    __throw_length_error("invalid value for socket option resize");

  2228. 	}

  2229. 

  2230.     protected:

  2231.       union

  2232.       {

  2233. 	ipv6_mreq _M_v6;

  2234. 	ip_mreq _M_v4;

  2235.       } _M_value;

  2236.     };

  2237. 

  2238.     /// Request that a socket leaves a multicast group.

  2239.     struct leave_group

  2240.     {

  2241.       explicit

  2242.       leave_group(const address&);

  2243. 

  2244.       explicit

  2245.       leave_group(const address_v4&, const address_v4& = address_v4::any());

  2246. 

  2247.       explicit

  2248.       leave_group(const address_v6&, unsigned int = 0);

  2249. 

  2250.       template<typename _Protocol>

  2251. 	int

  2252. 	level(const _Protocol& __p) const noexcept

  2253. 	{ return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; }

  2254. 

  2255.       template<typename _Protocol>

  2256. 	int

  2257. 	name(const _Protocol& __p) const noexcept

  2258. 	{

  2259. 	  return __p.family() == AF_INET6

  2260. 	    ? IPV6_LEAVE_GROUP : IP_DROP_MEMBERSHIP;

  2261. 	}

  2262.       template<typename _Protocol>

  2263. 	void*

  2264. 	data(const _Protocol&) noexcept

  2265. 	{ return std::addressof(_M_value); }

  2266. 

  2267.       template<typename _Protocol>

  2268. 	const void*

  2269. 	data(const _Protocol&) const noexcept

  2270. 	{ return std::addressof(_M_value); }

  2271. 

  2272.       template<typename _Protocol>

  2273. 	size_t

  2274. 	size(const _Protocol& __p) const noexcept

  2275. 	{

  2276. 	  return __p.family() == AF_INET6

  2277. 	    ? sizeof(_M_value._M_v6) : sizeof(_M_value._M_v4);

  2278. 	}

  2279. 

  2280.       template<typename _Protocol>

  2281. 	void

  2282. 	resize(const _Protocol& __p, size_t __s)

  2283. 	{

  2284. 	  if (__s != size(__p))

  2285. 	    __throw_length_error("invalid value for socket option resize");

  2286. 	}

  2287. 

  2288.     protected:

  2289.       union

  2290.       {

  2291. 	ipv6_mreq _M_v6;

  2292. 	ip_mreq _M_v4;

  2293.       } _M_value;

  2294.     };

  2295. 

  2296.     /// Specify the network interface for outgoing multicast datagrams.

  2297.     class outbound_interface

  2298.     {

  2299.       explicit

  2300.       outbound_interface(const address_v4&);

  2301. 

  2302.       explicit

  2303.       outbound_interface(unsigned int);

  2304. 

  2305.       template<typename _Protocol>

  2306. 	int

  2307. 	level(const _Protocol& __p) const noexcept

  2308. 	{ return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; }

  2309. 

  2310.       template<typename _Protocol>

  2311. 	int

  2312. 	name(const _Protocol& __p) const noexcept

  2313. 	{

  2314. 	  return __p.family() == AF_INET6

  2315. 	    ? IPV6_MULTICAST_IF : IP_MULTICAST_IF;

  2316. 	}

  2317. 

  2318.       template<typename _Protocol>

  2319. 	const void*

  2320. 	data(const _Protocol&) const noexcept

  2321. 	{ return std::addressof(_M_value); }

  2322. 

  2323.       template<typename _Protocol>

  2324. 	size_t

  2325. 	size(const _Protocol& __p) const noexcept

  2326. 	{

  2327. 	  return __p.family() == AF_INET6

  2328. 	    ? sizeof(_M_value._M_v6) : sizeof(_M_value._M_v4);

  2329. 	}

  2330. 

  2331.     protected:

  2332.       union {

  2333. 	unsigned _M_v6;

  2334. 	in_addr _M_v4;

  2335.       } _M_value;

  2336.     };

  2337. 

  2338.     /// Set the default number of hops (TTL) for outbound datagrams.

  2339.     struct hops : __sockopt_crtp<hops>

  2340.     {

  2341.       using __sockopt_crtp::__sockopt_crtp;

  2342. 

  2343.       template<typename _Protocol>

  2344. 	int

  2345. 	level(const _Protocol& __p) const noexcept

  2346. 	{ return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; }

  2347. 

  2348.       template<typename _Protocol>

  2349. 	int

  2350. 	name(const _Protocol& __p) const noexcept

  2351. 	{

  2352. 	  return __p.family() == AF_INET6

  2353. 	    ? IPV6_MULTICAST_HOPS : IP_MULTICAST_TTL;

  2354. 	}

  2355.     };

  2356. 

  2357.     /// Set whether datagrams are delivered back to the local application.

  2358.     struct enable_loopback : __sockopt_crtp<enable_loopback>

  2359.     {

  2360.       using __sockopt_crtp::__sockopt_crtp;

  2361. 

  2362.       template<typename _Protocol>

  2363. 	int

  2364. 	level(const _Protocol& __p) const noexcept

  2365. 	{ return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; }

  2366. 

  2367.       template<typename _Protocol>

  2368. 	int

  2369. 	name(const _Protocol& __p) const noexcept

  2370. 	{

  2371. 	  return __p.family() == AF_INET6

  2372. 	    ? IPV6_MULTICAST_LOOP : IP_MULTICAST_LOOP;

  2373. 	}

  2374.     };

  2375. 

  2376.   } // namespace multicast

  2377. 

  2378.   // @}

  2379. 

  2380. } // namespace ip

  2381. } // namespace v1

  2382. } // namespace net

  2383. } // namespace experimental

  2384. 

  2385.   template<>

  2386.     struct is_error_condition_enum<experimental::net::v1::ip::resolver_errc>

  2387.     : public true_type {};

  2388. 

  2389.   // hash support

  2390.   template<typename _Tp> struct hash;

  2391.   template<>

  2392.     struct hash<experimental::net::v1::ip::address>

  2393.     : __hash_base<size_t, experimental::net::v1::ip::address>

  2394.     {

  2395.       size_t

  2396.       operator()(const argument_type& __a) const

  2397.       {

  2398. 	if (__a.is_v4())

  2399. 	  return _Hash_impl::hash(__a.to_v4());

  2400. 	else

  2401. 	  return _Hash_impl::hash(__a.to_v6());

  2402.       }

  2403.     };

  2404. 

  2405.   template<>

  2406.     struct hash<experimental::net::v1::ip::address_v4>

  2407.     : __hash_base<size_t, experimental::net::v1::ip::address_v4>

  2408.     {

  2409.       size_t

  2410.       operator()(const argument_type& __a) const

  2411.       { return _Hash_impl::hash(__a.to_bytes()); }

  2412.     };

  2413. 

  2414.   template<> struct hash<experimental::net::v1::ip::address_v6>

  2415.     : __hash_base<size_t, experimental::net::v1::ip::address_v6>

  2416.     {

  2417.       size_t

  2418.       operator()(const argument_type& __a) const

  2419.       { return _Hash_impl::hash(__a.to_bytes()); }

  2420.     };

  2421. 

  2422. _GLIBCXX_END_NAMESPACE_VERSION

  2423. } // namespace std

  2424. 

  2425. #endif // C++14

  2426. 

  2427. #endif // _GLIBCXX_EXPERIMENTAL_INTERNET