├── COPYING ├── LICENSE_1_0.txt ├── README.md ├── bin └── .gitignore ├── doc ├── Jamfile.v2 ├── addstyle.pl ├── classes │ ├── hash.qbk │ ├── ip__address.qbk │ ├── ip__address_v4.qbk │ ├── ip__address_v6.qbk │ └── ip__bad_address_cast.qbk ├── definitions.qbk ├── error_reporting.qbk ├── functions │ ├── ip__address_cast.qbk │ └── literals.qbk ├── headers │ └── network.qbk └── proposal.qbk ├── include ├── network └── std │ └── net │ ├── detail │ ├── config.hpp │ ├── impl │ │ ├── socket_ops.ipp │ │ ├── system_errors.ipp │ │ ├── throw_error.ipp │ │ └── winsock_init.ipp │ ├── local_free_on_block_exit.hpp │ ├── old_win_sdk_compat.hpp │ ├── pop_options.hpp │ ├── push_options.hpp │ ├── socket_ops.hpp │ ├── socket_types.hpp │ ├── system_errors.hpp │ ├── throw_error.hpp │ ├── throw_exception.hpp │ └── winsock_init.hpp │ ├── ip │ ├── address.hpp │ ├── address_cast.hpp │ ├── address_v4.hpp │ ├── address_v6.hpp │ ├── bad_address_cast.hpp │ ├── fwd.hpp │ └── impl │ │ ├── address.hpp │ │ ├── address.ipp │ │ ├── address_v4.hpp │ │ ├── address_v4.ipp │ │ ├── address_v6.hpp │ │ └── address_v6.ipp │ └── literals.hpp ├── project-root.jam └── tests ├── .gitignore ├── Makefile ├── ip ├── address.cpp ├── address.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── address ├── address_v4.cpp └── address_v6.cpp ├── network.cpp └── unit_test.hpp /COPYING: -------------------------------------------------------------------------------- 1 | Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 2 | 3 | Distributed under the Boost Software License, Version 1.0. (See accompanying 4 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | -------------------------------------------------------------------------------- /LICENSE_1_0.txt: -------------------------------------------------------------------------------- 1 | Boost Software License - Version 1.0 - August 17th, 2003 2 | 3 | Permission is hereby granted, free of charge, to any person or organization 4 | obtaining a copy of the software and accompanying documentation covered by 5 | this license (the "Software") to use, reproduce, display, distribute, 6 | execute, and transmit the Software, and to prepare derivative works of the 7 | Software, and to permit third-parties to whom the Software is furnished to 8 | do so, all subject to the following: 9 | 10 | The copyright notices in the Software and this entire statement, including 11 | the above license grant, this restriction and the following disclaimer, 12 | must be included in all copies of the Software, in whole or in part, and 13 | all derivative works of the Software, unless such copies or derivative 14 | works are solely in the form of machine-executable object code generated by 15 | a source language processor. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 20 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 21 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 22 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 | DEALINGS IN THE SOFTWARE. 24 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | IP Address Proposal 2 | =================== 3 | 4 | Proposed IP addresses classes for the standard C++ library. 5 | 6 | What's Included 7 | --------------- 8 | 9 | * `./doc` - Proposed text using Boost.Quickbook format. 10 | * `./include` - Reference implementation. 11 | * `./tests` - Unit tests for reference implementation. 12 | 13 | Tested Platforms 14 | ---------------- 15 | 16 | * Mac OS 10.8 using g++ 4.7 (requires `-std=c++11`) 17 | * Mac OS 10.8 using clang++ from Xcode 4.6 (requires `-std=c++11` and `-stdlib=libc++`) 18 | * Linux (CentOS 6.2) using g++ 4.7 (requires `-std=c++11`) 19 | * Windows 7 32-bit using Visual Studio 2010 20 | * Windows 7 x64 using Visual Studio 2010 21 | -------------------------------------------------------------------------------- /bin/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | -------------------------------------------------------------------------------- /doc/Jamfile.v2: -------------------------------------------------------------------------------- 1 | project asio-tr2-doc 2 | : build-dir ../bin 3 | ; 4 | 5 | using quickbook ; 6 | 7 | boostbook proposal 8 | : 9 | proposal.qbk 10 | : 11 | toc.section.depth=6 12 | section.autolabel=1 13 | toc.max.depth=6 14 | onehtml 15 | ; 16 | 17 | # install html : design/membar.png ; 18 | -------------------------------------------------------------------------------- /doc/addstyle.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl -w 2 | 3 | use strict; 4 | 5 | if (@ARGV != 1) 6 | { 7 | print "Usage: addstyle \n"; 8 | exit; 9 | } 10 | 11 | my $style = 12 | ""; 19 | 20 | my $rev = `git rev-parse HEAD`; 21 | chomp($rev); 22 | my $draft_info = " (as of commit $rev)"; 23 | 24 | my $docno = 25 | "
" .
26 | "Doc. no:  D4044 " . $draft_info . "\n" .
27 | "Date:     2014-05-24\n" .
28 | "Revises:  N3603\n" .
29 | "Reply-To: Christopher Kohlhoff <chris\@kohlhoff.com>\n" .
30 | "
\n"; 31 | 32 | my @lines = (); 33 | my $saw_h4 = 0; 34 | 35 | my $filename = ${ARGV}[0]; 36 | open my $file_in, "<$filename" or die "Can't open $filename"; 37 | while (my $line = <$file_in>) 38 | { 39 | $line =~ s~\~\$style~; 40 | $line =~ s~\~\$docno~; 41 | $line =~ s/\240/ /g; 42 | if ($line =~ /

/) 43 | { 44 | $line =~ s/

/

/; 45 | $saw_h4 = 1; 46 | } 47 | if ($saw_h4 and $line =~ /<\/h4>/) 48 | { 49 | $line =~ s/<\/h4>/<\/p>/; 50 | $saw_h4 = 0; 51 | } 52 | if ($line =~ /

/) 53 | { 54 | $line =~ s/

/

/; 55 | } 56 | push @lines, $line; 57 | } 58 | close $file_in; 59 | 60 | open my $file_out, ">$filename" or die "Can't open $filename"; 61 | foreach my $line (@lines) 62 | { 63 | print $file_out $line; 64 | } 65 | close $file_out; 66 | -------------------------------------------------------------------------------- /doc/classes/hash.qbk: -------------------------------------------------------------------------------- 1 | [section:hash Hash support] 2 | 3 | template <> struct hash; 4 | template <> struct hash; 5 | template <> struct hash; 6 | 7 | [function_requires the template specializations shall meet the requirements of 8 | class template `hash` (C++14 \[unord.hash\]).] 9 | 10 | [endsect] 11 | -------------------------------------------------------------------------------- /doc/classes/ip__address.qbk: -------------------------------------------------------------------------------- 1 | [section:ip__address Class [^ip::address]] 2 | 3 | namespace std { 4 | namespace experimental { 5 | namespace net { 6 | namespace ip { 7 | 8 | class address 9 | { 10 | public: 11 | // constructors: 12 | constexpr address() noexcept; 13 | constexpr address(const address& a) noexcept; 14 | template constexpr address(const T& t) noexcept(``['see below]``); 15 | template explicit constexpr address(T&&... t); 16 | 17 | // assignment: 18 | address& operator=(const address& a) noexcept; 19 | 20 | // members: 21 | constexpr bool is_unspecified() const noexcept; 22 | constexpr bool is_loopback() const noexcept; 23 | constexpr bool is_multicast() const noexcept; 24 | constexpr bool is_v4() const noexcept; 25 | constexpr bool is_v6() const noexcept; 26 | string to_string() const; 27 | string to_string(error_code& ec) const; 28 | }; 29 | 30 | // address comparisons: 31 | bool operator==(const address& a, const address& b) noexcept; 32 | bool operator!=(const address& a, const address& b) noexcept; 33 | bool operator< (const address& a, const address& b) noexcept; 34 | bool operator> (const address& a, const address& b) noexcept; 35 | bool operator<=(const address& a, const address& b) noexcept; 36 | bool operator>=(const address& a, const address& b) noexcept; 37 | 38 | // address creation: 39 | address make_address(const char*); 40 | address make_address(const char*, error_code&) noexcept; 41 | address make_address(const string&); 42 | address make_address(const string&, error_code&) noexcept; 43 | 44 | // address I/O: 45 | template 46 | basic_ostream& operator<<( 47 | basic_ostream& os, const address& addr); 48 | 49 | } // namespace ip 50 | } // namespace net 51 | } // namespace experimental 52 | } // namespace std 53 | 54 | [section [^ip::address] constructors] 55 | 56 | constexpr address() noexcept; 57 | 58 | [function_effects Constructs an object of class `address`.] 59 | 60 | [function_postconditions The postconditions of this function are indicated in 61 | the table below.] 62 | 63 | [table address::address() effects 64 | [[expression][value]] 65 | [ 66 | [`is_v4()`] 67 | [`false`] 68 | ] 69 | [ 70 | [`is_v6()`] 71 | [`false`] 72 | ] 73 | ] 74 | 75 | constexpr address(const address& a) noexcept; 76 | 77 | [function_effects Constructs an object of class `address`.] 78 | 79 | [function_postconditions `*this == a`] 80 | 81 | template constexpr address(const T& t) noexcept(``['see below]``); 82 | 83 | [function_remarks This constructor shall not participate in overload resolution 84 | unless `is_same::value` is `false`, and the expression 85 | `address_cast

(t)` is valid and yields an rvalue of type `address`. The 86 | expression inside `noexcept` shall be equivalent to 87 | `noexcept(address_cast
(t))`.] 88 | 89 | [function_effects Constructs an object of type `address` with the result of the 90 | expression `address_cast
(t)`.] 91 | 92 | [function_throws Nothing unless the expression `address_cast
(t)` 93 | throws an exception.] 94 | 95 | template explicit constexpr address(T&&... t); 96 | 97 | [function_remarks This constructor shall not participate in overload resolution 98 | unless the expression `make_address(forward(t).``.``.)` is valid and yields an 99 | rvalue of type `address`.] 100 | 101 | [function_effects Constructs an object of type `address` with the result of the 102 | expression `make_address(forward(t).``.``.)`.] 103 | 104 | [endsect] 105 | 106 | [section [^ip::address] assignment] 107 | 108 | address& operator=(const address& a) noexcept; 109 | 110 | [function_postconditions `*this == a`] 111 | 112 | [function_returns `*this`] 113 | 114 | [endsect] 115 | 116 | [section [^ip::address] members] 117 | 118 | constexpr bool is_unspecified() const noexcept; 119 | 120 | [function_returns If `is_v4() == true`, returns 121 | `address_cast(*this).is_unspecified()`. If `is_v6() == true`, returns 122 | `address_cast(*this).is_unspecified()`. Otherwise returns `false`.] 123 | 124 | constexpr bool is_loopback() const noexcept; 125 | 126 | [function_returns If `is_v4() == true`, returns 127 | `address_cast(*this).is_loopback()`. If `is_v6() == true`, returns 128 | `address_cast(*this).is_loopback()`. Otherwise returns `false`.] 129 | 130 | constexpr bool is_multicast() const noexcept; 131 | 132 | [function_returns If `is_v4() == true`, returns 133 | `address_cast(*this).is_multicast()`. If `is_v6() == true`, returns 134 | `address_cast(*this).is_multicast()`. Otherwise returns `false`.] 135 | 136 | constexpr bool is_v4() const noexcept; 137 | 138 | [function_returns `true` if the object contains an IP version 4 address.] 139 | 140 | constexpr bool is_v6() const noexcept; 141 | 142 | [function_returns `true` if the object contains an IP version 6 address.] 143 | 144 | string to_string() const; 145 | string to_string(error_code& ec) const; 146 | 147 | [function_returns If `is_v4() == true`, returns 148 | `address_cast(*this).to_string(ec)`. If `is_v6() == true`, returns 149 | `address_cast(*this).to_string(ec)`. Otherwise throws `bad_address_cast`.] 150 | 151 | [endsect] 152 | 153 | [section:ip__address__comparisons [^ip::address] comparisons] 154 | 155 | bool operator==(const address& a, const address& b) noexcept; 156 | 157 | [function_returns `a_v4 == b_v4 && a_v6 == b_v6`, where:[br] 158 | [mdash] `a_v4` is the value of `a.is_v4() ? address_cast(a) : address_v4()`;[br] 159 | [mdash] `b_v4` is `b.is_v4() ? address_cast(b) : address_v4()`;[br] 160 | [mdash] `a_v6` is `a.is_v6() ? address_cast(a) : address_v6()`; and[br] 161 | [mdash] `b_v6` is `b.is_v6() ? address_cast(b) : address_v6()`.] 162 | 163 | bool operator!=(const address& a, const address& b) noexcept; 164 | 165 | [function_returns `!(a == b)`.] 166 | 167 | bool operator< (const address& a, const address& b) noexcept; 168 | 169 | [function_returns `a_v6 < b_v6 || a_v6 == b_v6 && a_v4 < b_v4`, where:[br] 170 | [mdash] `a_v4` is the value of `a.is_v4() ? address_cast(a) : address_v4()`;[br] 171 | [mdash] `b_v4` is `b.is_v4() ? address_cast(b) : address_v4()`;[br] 172 | [mdash] `a_v6` is `a.is_v6() ? address_cast(a) : address_v6()`; and[br] 173 | [mdash] `b_v6` is `b.is_v6() ? address_cast(b) : address_v6()`.] 174 | 175 | bool operator> (const address& a, const address& b) noexcept; 176 | 177 | [function_returns `b < a`.] 178 | 179 | bool operator<=(const address& a, const address& b) noexcept; 180 | 181 | [function_returns `!(b < a)`.] 182 | 183 | bool operator>=(const address& a, const address& b) noexcept; 184 | 185 | [function_returns `!(a < b)`.] 186 | 187 | [endsect] 188 | 189 | [section:ip__address__creation [^ip::address] creation] 190 | 191 | address make_address(const char* str); 192 | address make_address(const char* str, error_code& ec) noexcept; 193 | address make_address(const string& str); 194 | address make_address(const string& str, error_code& ec) noexcept; 195 | 196 | [function_effects Converts a string representation of an address into an object 197 | of class `address`, as if by calling: 198 | `` 199 | address a; 200 | address_v6 v6a = make_address_v6(str, ec); 201 | if (!ec) 202 | a = v6a; 203 | else 204 | { 205 | address_v4 v4a = make_address_v4(str, ec); 206 | if (!ec) 207 | a = v4a; 208 | } 209 | ``] 210 | 211 | [function_returns `a`.] 212 | 213 | [endsect] 214 | 215 | [section:ip__address__io [^ip::address] I/O] 216 | 217 | template 218 | basic_ostream& operator<<( 219 | basic_ostream& os, const address& addr); 220 | 221 | [function_effects Outputs the string representation of the address to the 222 | stream, as if it were implemented as follows: 223 | `` 224 | error_code ec; 225 | string s = addr.to_string(ec); 226 | if (ec) 227 | { 228 | if (os.exceptions() & ios_base::failbit) 229 | throw system_error(ec); 230 | else 231 | os.setstate(ios_base::failbit); 232 | } 233 | else 234 | for (string::iterator i = s.begin(); i != s.end(); ++i) 235 | os << os.widen(*i); 236 | ``] 237 | 238 | [function_returns `os`.] 239 | 240 | [endsect] 241 | 242 | [endsect] 243 | -------------------------------------------------------------------------------- /doc/classes/ip__address_v4.qbk: -------------------------------------------------------------------------------- 1 | [section:ip__address_v4 Class [^ip::address_v4]] 2 | 3 | namespace std { 4 | namespace experimental { 5 | namespace net { 6 | namespace ip { 7 | 8 | class address_v4 9 | { 10 | public: 11 | // types: 12 | struct bytes_type; 13 | 14 | // constructors: 15 | constexpr address_v4() noexcept; 16 | constexpr address_v4(const address_v4& a) noexcept; 17 | constexpr address_v4(const bytes_type& bytes); 18 | template explicit constexpr address(T&&... t); 19 | 20 | // assignment: 21 | address_v4& operator=(const address_v4& a) noexcept; 22 | 23 | // members: 24 | constexpr bool is_unspecified() const noexcept; 25 | constexpr bool is_loopback() const noexcept; 26 | constexpr bool is_class_a() const noexcept; 27 | constexpr bool is_class_b() const noexcept; 28 | constexpr bool is_class_c() const noexcept; 29 | constexpr bool is_multicast() const noexcept; 30 | constexpr bytes_type to_bytes() const noexcept; 31 | constexpr unsigned long to_ulong() const noexcept; 32 | string to_string() const; 33 | string to_string(error_code& ec) const; 34 | 35 | // static members: 36 | static constexpr address_v4 any() noexcept; 37 | static constexpr address_v4 loopback() noexcept; 38 | static constexpr address_v4 broadcast() noexcept; 39 | static constexpr address_v4 broadcast(const address_v4& addr, 40 | const address_v4& mask) noexcept; 41 | }; 42 | 43 | // address_v4 comparisons: 44 | bool operator==(const address_v4& a, const address_v4& b) noexcept; 45 | bool operator!=(const address_v4& a, const address_v4& b) noexcept; 46 | bool operator< (const address_v4& a, const address_v4& b) noexcept; 47 | bool operator> (const address_v4& a, const address_v4& b) noexcept; 48 | bool operator<=(const address_v4& a, const address_v4& b) noexcept; 49 | bool operator>=(const address_v4& a, const address_v4& b) noexcept; 50 | 51 | // address_v4 creation: 52 | constexpr address_v4 make_address_v4(const address_v4::bytes_type&); 53 | constexpr address_v4 make_address_v4(unsigned long); 54 | constexpr address_v4 make_address_v4(v4_mapped_t, const address_v6&); 55 | address_v4 make_address_v4(const char*); 56 | address_v4 make_address_v4(const char*, error_code&) noexcept; 57 | address_v4 make_address_v4(const string&); 58 | address_v4 make_address_v4(const string&, error_code&) noexcept; 59 | 60 | // address_v4 I/O: 61 | template 62 | basic_ostream& operator<<( 63 | basic_ostream& os, const address_v4& addr); 64 | 65 | } // namespace ip 66 | } // namespace net 67 | } // namespace experimental 68 | } // namespace std 69 | 70 | [section Struct [^ip::address_v4::bytes_type]] 71 | 72 | namespace std { 73 | namespace experimental { 74 | namespace net { 75 | namespace ip { 76 | 77 | struct address_v4::bytes_type : array 78 | { 79 | template explicit constexpr bytes_type(T... t) 80 | : array{{static_cast(t)...}} {} 81 | }; 82 | 83 | } // namespace ip 84 | } // namespace net 85 | } // namespace experimental 86 | } // namespace std 87 | 88 | The [^ip::address_v4::bytes_type] type is a standard-layout struct that provides a 89 | byte-level representation of an IPv4 address in network byte order. 90 | 91 | [endsect] 92 | 93 | [section [^ip::address_v4] constructors] 94 | 95 | constexpr address_v4() noexcept; 96 | 97 | [function_effects Constructs an object of class `address_v4`.] 98 | 99 | [function_postconditions The postconditions of this function are indicated in 100 | the table below.] 101 | 102 | [table address_v4::address_v4() effects 103 | [[expression][value]] 104 | [[`to_bytes()`][`{0, 0, 0, 0}`]] 105 | [[`to_ulong()`][`0`]] 106 | ] 107 | 108 | constexpr address_v4(const address_v4& a) noexcept; 109 | 110 | [function_effects Constructs an object of class `address_v4`.] 111 | 112 | [function_postconditions `*this == a`] 113 | 114 | constexpr address_v4(const bytes_type& bytes); 115 | 116 | [function_requires Each element of `bytes` is in the range `[0, 0xFF]`.] 117 | 118 | [function_throws `out_of_range` if any element of `bytes` is not in the range 119 | `[0, 0xFF]`. [inline_note For implementations where `UCHAR_MAX == 0xFF`, no 120 | out-of-range detection is needed.]] 121 | 122 | [function_postconditions `to_bytes() == bytes` and `to_ulong() == (bytes[0] 123 | << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]`.] 124 | 125 | template explicit constexpr address_v4(T&&... t); 126 | 127 | [function_remarks This constructor shall not participate in overload resolution 128 | unless the expression `make_address_v4(forward(t).``.``.)` is valid and yields an 129 | rvalue of type `address_v4`.] 130 | 131 | [function_effects Constructs an object of type `address_v4` with the result of 132 | the expression `make_address_v4(forward(t).``.``.)`.] 133 | 134 | [endsect] 135 | 136 | [section [^ip::address_v4] assignment] 137 | 138 | address_v4& operator=(const address_v4& a) noexcept; 139 | 140 | [function_postconditions `*this == a`] 141 | 142 | [function_returns `*this`] 143 | 144 | [endsect] 145 | 146 | [section [^ip::address_v4] members] 147 | 148 | constexpr bool is_unspecified() const noexcept; 149 | 150 | [function_returns `to_ulong() == 0`.] 151 | 152 | constexpr bool is_loopback() const noexcept; 153 | 154 | [function_returns `(to_ulong() & 0xFF000000) == 0x7F000000`.] 155 | 156 | constexpr bool is_class_a() const noexcept; 157 | 158 | [function_returns `(to_ulong() & 0x80000000) == 0`.] 159 | 160 | constexpr bool is_class_b() const noexcept; 161 | 162 | [function_returns `(to_ulong() & 0xC0000000) == 0x80000000`.] 163 | 164 | constexpr bool is_class_c() const noexcept; 165 | 166 | [function_returns `(to_ulong() & 0xE0000000) == 0xC0000000`.] 167 | 168 | constexpr bool is_multicast() const noexcept; 169 | 170 | [function_returns `(to_ulong() & 0xF0000000) == 0xE0000000`.] 171 | 172 | constexpr bytes_type to_bytes() const noexcept; 173 | 174 | [function_returns A representation of the address in [link 175 | definitions.network_byte_order network byte order].] 176 | 177 | constexpr unsigned long to_ulong() const noexcept; 178 | 179 | [function_returns A representation of the address in [link 180 | definitions.host_byte_order host byte order].] 181 | 182 | string to_string() const; 183 | string to_string(error_code& ec) const; 184 | 185 | [function_effects Converts an address into a string representation, as if by 186 | __POSIX__ __inet_ntop__ when invoked with address family `AF_INET`.] 187 | 188 | [function_returns If successful, the string representation of the address. 189 | Otherwise `string()`.] 190 | 191 | [endsect] 192 | 193 | [section [^ip::address_v4] static members] 194 | 195 | static constexpr address_v4 any() noexcept; 196 | 197 | [function_returns `address_v4()`.] 198 | 199 | static constexpr address_v4 loopback() noexcept; 200 | 201 | [function_returns `address_v4(0x7F000001)`.] 202 | 203 | static constexpr address_v4 broadcast() noexcept; 204 | 205 | [function_returns `address_v4(0xFFFFFFFF)`.] 206 | 207 | static constexpr address_v4 broadcast(const address_v4& addr, const address_v4& mask) noexcept; 208 | 209 | [function_returns `address_v4(addr.to_ulong() | ~mask.to_ulong())`.] 210 | 211 | [endsect] 212 | 213 | [section:ip__address_v4__comparisons [^ip::address_v4] comparisons] 214 | 215 | bool operator==(const address_v4& a, const address_v4& b) noexcept; 216 | 217 | [function_returns `a.to_ulong() == b.to_ulong()`.] 218 | 219 | bool operator!=(const address_v4& a, const address_v4& b) noexcept; 220 | 221 | [function_returns `a.to_ulong() != b.to_ulong()`.] 222 | 223 | bool operator< (const address_v4& a, const address_v4& b) noexcept; 224 | 225 | [function_returns `a.to_ulong() < b.to_ulong()`.] 226 | 227 | bool operator> (const address_v4& a, const address_v4& b) noexcept; 228 | 229 | [function_returns `a.to_ulong() > b.to_ulong()`.] 230 | 231 | bool operator<=(const address_v4& a, const address_v4& b) noexcept; 232 | 233 | [function_returns `a.to_ulong() <= b.to_ulong()`.] 234 | 235 | bool operator>=(const address_v4& a, const address_v4& b) noexcept; 236 | 237 | [function_returns `a.to_ulong() >= b.to_ulong()`.] 238 | 239 | [endsect] 240 | 241 | [section:ip__address_v4__creation [^ip::address_v4] creation] 242 | 243 | constexpr address_v4 make_address_v4(const address_v4::bytes_type& bytes); 244 | 245 | [function_returns `address_v4(bytes)`.] 246 | 247 | constexpr address_v4 make_address_v4(unsigned long val); 248 | 249 | [function_requires `val` is in the range `[0, 0xFFFFFFFF]`.] 250 | 251 | [function_throws `out_of_range` if `val` is not in the range `[0, 0xFFFFFFFF]`. 252 | [inline_note For implementations where `ULONG_MAX == 0xFFFFFFFF`, no 253 | out-of-range detection is needed.]] 254 | 255 | [function_returns An object `a` of type `address_v4` where `a.to_ulong() == 256 | val` and `a.to_bytes()` is `{ (val >> 24) & 0xFF, (val >> 16) & 0xFF, 257 | (val >> 8) & 0xFF, val & 0xFF }`.] 258 | 259 | constexpr address_v4 make_address_v4(v4_mapped_t, const address_v6& a); 260 | 261 | [function_requires `a.is_v4_mapped()`.] 262 | 263 | [function_returns An `address_v4` object corresponding to the IPv4-mapped IPv6 264 | address, as if computed by the following method: 265 | `` 266 | bytes_type v6b = a.to_bytes(); 267 | address_v4::bytes_type v4b(v6b[12], v6b[13], v6b[14], v6b[15]); 268 | return address_v4(v4b); 269 | ``] 270 | 271 | [function_throws `bad_address_cast` if `a.is_v4_mapped()` is false.] 272 | 273 | address_v4 make_address_v4(const char* str); 274 | address_v4 make_address_v4(const char* str, error_code& ec) noexcept; 275 | address_v4 make_address_v4(const string& str); 276 | address_v4 make_address_v4(const string& str, error_code& ec) noexcept; 277 | 278 | [function_effects Converts a string representation of an address into a 279 | corresponding `address_v4` value, as if by __POSIX__ __inet_pton__ when invoked 280 | with address family `AF_INET`.] 281 | 282 | [function_returns If successful, an `address_v4` value corresponding to the 283 | string `str`. Otherwise `address_v4()`.] 284 | 285 | [endsect] 286 | 287 | [section:ip__address_v4__io [^ip::address_v4] I/O] 288 | 289 | template 290 | basic_ostream& operator<<( 291 | basic_ostream& os, const address_v4& addr); 292 | 293 | [function_effects Outputs the string representation of the address to the 294 | stream, as if it were implemented as follows: 295 | `` 296 | error_code ec; 297 | string s = addr.to_string(ec); 298 | if (ec) 299 | { 300 | if (os.exceptions() & ios_base::failbit) 301 | throw system_error(ec); 302 | else 303 | os.setstate(ios_base::failbit); 304 | } 305 | else 306 | for (string::iterator i = s.begin(); i != s.end(); ++i) 307 | os << os.widen(*i); 308 | ``] 309 | 310 | [function_returns `os`.] 311 | 312 | [endsect] 313 | 314 | [endsect] 315 | -------------------------------------------------------------------------------- /doc/classes/ip__address_v6.qbk: -------------------------------------------------------------------------------- 1 | [section:ip__address_v6 Class [^ip::address_v6]] 2 | 3 | namespace std { 4 | namespace experimental { 5 | namespace net { 6 | namespace ip { 7 | 8 | class address_v6 9 | { 10 | public: 11 | // types: 12 | struct bytes_type; 13 | 14 | // constructors: 15 | constexpr address_v6() noexcept; 16 | constexpr address_v6(const address_v6& a) noexcept; 17 | constexpr address_v6(const bytes_type& bytes, unsigned long scope); 18 | template explicit constexpr address(T&&... t); 19 | 20 | // assignment: 21 | address_v4& operator=(const address_v4& a) noexcept; 22 | 23 | // members: 24 | void scope_id(unsigned long id) noexcept; 25 | constexpr unsigned long scope_id() const noexcept; 26 | constexpr bool is_unspecified() const noexcept; 27 | constexpr bool is_loopback() const noexcept; 28 | constexpr bool is_multicast() const noexcept; 29 | constexpr bool is_link_local() const noexcept; 30 | constexpr bool is_site_local() const noexcept; 31 | constexpr bool is_v4_mapped() const noexcept; 32 | constexpr bool is_multicast_node_local() const noexcept; 33 | constexpr bool is_multicast_link_local() const noexcept; 34 | constexpr bool is_multicast_site_local() const noexcept; 35 | constexpr bool is_multicast_org_local() const noexcept; 36 | constexpr bool is_multicast_global() const noexcept; 37 | constexpr bytes_type to_bytes() const noexcept; 38 | string to_string() const; 39 | string to_string(error_code& ec) const; 40 | 41 | // static members: 42 | static constexpr address_v6 any() noexcept; 43 | static constexpr address_v6 loopback() noexcept; 44 | }; 45 | 46 | // address_v6 comparisons: 47 | bool operator==(const address_v6& a, const address_v6& b) noexcept; 48 | bool operator!=(const address_v6& a, const address_v6& b) noexcept; 49 | bool operator< (const address_v6& a, const address_v6& b) noexcept; 50 | bool operator> (const address_v6& a, const address_v6& b) noexcept; 51 | bool operator<=(const address_v6& a, const address_v6& b) noexcept; 52 | bool operator>=(const address_v6& a, const address_v6& b) noexcept; 53 | 54 | // address_v6 creation: 55 | constexpr address_v6 make_address_v6(const address_v6::bytes_type&, unsigned long = 0); 56 | constexpr address_v6 make_address_v6(v4_mapped_t, const address_v4&) noexcept; 57 | address_v6 make_address_v6(const char*); 58 | address_v6 make_address_v6(const char*, error_code&) noexcept; 59 | address_v6 make_address_v6(const string&); 60 | address_v6 make_address_v6(const string&, error_code&) noexcept; 61 | 62 | // address_v6 I/O: 63 | template 64 | basic_ostream& operator<<( 65 | basic_ostream& os, const address_v6& addr); 66 | 67 | } // namespace ip 68 | } // namespace net 69 | } // namespace experimental 70 | } // namespace std 71 | 72 | [std_note The implementations of the functions `is_unspecified`, `is_loopback`, 73 | `is_multicast`, `is_link_local`, `is_site_local`, `is_v4_mapped`, 74 | `is_multicast_node_local`, `is_multicast_link_local`, `is_multicast_site_local`, 75 | `is_multicast_org_local` and `is_multicast_global` are determined by [RFC4291].] 76 | 77 | [section Struct [^ip::address_v6::bytes_type]] 78 | 79 | namespace std { 80 | namespace experimental { 81 | namespace net { 82 | namespace ip { 83 | 84 | struct address_v6::bytes_type : array 85 | { 86 | template explicit constexpr bytes_type(T... t) 87 | : array{{static_cast(t)...}} {} 88 | }; 89 | 90 | } // namespace ip 91 | } // namespace net 92 | } // namespace experimental 93 | } // namespace std 94 | 95 | The [^ip::address_v6::bytes_type] type is a standard-layout struct that provides a 96 | byte-level representation of an IPv6 address in network byte order. 97 | 98 | [endsect] 99 | 100 | [section [^ip::address_v6] constructors] 101 | 102 | constexpr address_v6() noexcept; 103 | 104 | [function_effects Constructs an object of class `address_v6`.] 105 | 106 | [function_postconditions The postconditions of this function are indicated in 107 | the table below.] 108 | 109 | [table address_v6::address_v6() effects 110 | [[expression][value]] 111 | [[`is_unspecified()`][`true`]] 112 | [[`scope_id()`][`0`]] 113 | ] 114 | 115 | constexpr address_v6(const address_v6& a) noexcept; 116 | 117 | [function_effects Constructs an object of class `address_v6`.] 118 | 119 | [function_postconditions `*this == a`] 120 | 121 | constexpr address_v6(const bytes_type& bytes, unsigned long scope); 122 | 123 | [function_requires Each element of `bytes` is in the range `[0, 0xFF]`.] 124 | 125 | [function_throws `out_of_range` if any element of `bytes` is not in the range 126 | `[0, 0xFF]`. [inline_note For implementations where `UCHAR_MAX == 0xFF`, no 127 | out-of-range detection is needed.]] 128 | 129 | [function_postconditions `to_bytes() == bytes` and `scope_id() == scope`.] 130 | 131 | template explicit constexpr address_v6(T&&... t); 132 | 133 | [function_remarks This constructor shall not participate in overload resolution 134 | unless the expression `make_address_v6(forward(t).``.``.)` is valid and yields an 135 | rvalue of type `address_v6`.] 136 | 137 | [function_effects Constructs an object of type `address_v6` with the result of 138 | the expression `make_address_v6(forward(t).``.``.)`.] 139 | 140 | [endsect] 141 | 142 | [section [^ip::address_v6] assignment] 143 | 144 | address_v6& operator=(const address_v6& a) noexcept; 145 | 146 | [function_postconditions `*this == a`] 147 | 148 | [function_returns `*this`] 149 | 150 | [endsect] 151 | 152 | [section [^ip::address_v6] members] 153 | 154 | void scope_id(unsigned long id) noexcept; 155 | 156 | [function_postconditions `scope_id() == id`.] 157 | 158 | constexpr unsigned long scope_id() const noexcept; 159 | 160 | [function_returns The scope identifier associated with the address.] 161 | 162 | constexpr bool is_unspecified() const noexcept; 163 | 164 | [function_returns A boolean indicating whether the `address_v6` object 165 | represents an unspecified address, as if computed by the following method: 166 | `` 167 | bytes_type b = to_bytes(); 168 | return b[ 0] == 0 && b[ 1] == 0 && b[ 2] == 0 && b[ 3] == 0 169 | && b[ 4] == 0 && b[ 5] == 0 && b[ 6] == 0 && b[ 7] == 0 170 | && b[ 8] == 0 && b[ 9] == 0 && b[10] == 0 && b[11] == 0 171 | && b[12] == 0 && b[13] == 0 && b[14] == 0 && b[15] == 0; 172 | ``] 173 | 174 | constexpr bool is_loopback() const noexcept; 175 | 176 | [function_returns A boolean indicating whether the `address_v6` object 177 | represents a loopback address, as if computed by the following method: 178 | `` 179 | bytes_type b = to_bytes(); 180 | return b[ 0] == 0 && b[ 1] == 0 && b[ 2] == 0 && b[ 3] == 0 181 | && b[ 4] == 0 && b[ 5] == 0 && b[ 6] == 0 && b[ 7] == 0 182 | && b[ 8] == 0 && b[ 9] == 0 && b[10] == 0 && b[11] == 0 183 | && b[12] == 0 && b[13] == 0 && b[14] == 0 && b[15] == 1; 184 | ``] 185 | 186 | constexpr bool is_multicast() const noexcept; 187 | 188 | [function_returns A boolean indicating whether the `address_v6` object 189 | represents a multicast address, as if computed by the following method: 190 | `` 191 | bytes_type b = to_bytes(); 192 | return b[0] == 0xFF; 193 | ``] 194 | 195 | constexpr bool is_link_local() const noexcept; 196 | 197 | [function_returns A boolean indicating whether the `address_v6` object 198 | represents a unicast link-local address, as if computed by the following 199 | method: 200 | `` 201 | bytes_type b = to_bytes(); 202 | return b[0] == 0xFE && (b[1] & 0xC0) == 0x80; 203 | ``] 204 | 205 | constexpr bool is_site_local() const noexcept; 206 | 207 | [function_returns A boolean indicating whether the `address_v6` object 208 | represents a unicast site-local address, as if computed by the following 209 | method: 210 | `` 211 | bytes_type b = to_bytes(); 212 | return b[0] == 0xFE && (b[1] & 0xC0) == 0xC0; 213 | ``] 214 | 215 | constexpr bool is_v4_mapped() const noexcept; 216 | 217 | [function_returns A boolean indicating whether the `address_v6` object 218 | represents an IPv4-mapped IPv6 address, as if computed by the following method: 219 | `` 220 | bytes_type b = to_bytes(); 221 | return b[ 0] == 0 && b[ 1] == 0 && b[ 2] == 0 && b[ 3] == 0 222 | && b[ 4] == 0 && b[ 5] == 0 && b[ 6] == 0 && b[ 7] == 0 223 | && b[ 8] == 0 && b[ 9] == 0 && b[10] == 0xFF && b[11] == 0xFF; 224 | ``] 225 | 226 | constexpr bool is_multicast_node_local() const noexcept; 227 | 228 | [function_returns A boolean indicating whether the `address_v6` object 229 | represents a multicast node-local address, as if computed by the following 230 | method: 231 | `` 232 | bytes_type b = to_bytes(); 233 | return b[0] == 0xFF && (b[1] & 0x0F) == 0x01; 234 | ``] 235 | 236 | constexpr bool is_multicast_link_local() const noexcept; 237 | 238 | [function_returns A boolean indicating whether the `address_v6` object 239 | represents a multicast link-local address, as if computed by the following 240 | method: 241 | `` 242 | bytes_type b = to_bytes(); 243 | return b[0] == 0xFF && (b[1] & 0x0F) == 0x02; 244 | ``] 245 | 246 | constexpr bool is_multicast_site_local() const noexcept; 247 | 248 | [function_returns A boolean indicating whether the `address_v6` object 249 | represents a multicast site-local address, as if computed by the following 250 | method: 251 | `` 252 | bytes_type b = to_bytes(); 253 | return b[0] == 0xFF && (b[1] & 0x0F) == 0x05; 254 | ``] 255 | 256 | constexpr bool is_multicast_org_local() const noexcept; 257 | 258 | [function_returns A boolean indicating whether the `address_v6` object 259 | represents a multicast organisation-local address, as if computed by the 260 | following method: 261 | `` 262 | bytes_type b = to_bytes(); 263 | return b[0] == 0xFF && (b[1] & 0x0F) == 0x08; 264 | ``] 265 | 266 | constexpr bool is_multicast_global() const noexcept; 267 | 268 | [function_returns A boolean indicating whether the `address_v6` object 269 | represents a multicast global address, as if computed by the following method: 270 | `` 271 | bytes_type b = to_bytes(); 272 | return b[0] == 0xFF && (b[1] & 0x0F) == 0x0E; 273 | ``] 274 | 275 | constexpr bytes_type to_bytes() const noexcept; 276 | 277 | [function_returns A representation of the address in [link 278 | definitions.network_byte_order network byte order].] 279 | 280 | string to_string() const; 281 | string to_string(error_code& ec) const; 282 | 283 | [function_effects Converts an address into a string representation. If 284 | `scope_id() == 0`, converts as if by __POSIX__ __inet_ntop__ when invoked with 285 | address family `AF_INET6`. If `scope_id() != 0`, the format is 286 | ['`address`]`%`['`scope-id`], where ['`address`] is the string representation 287 | of the equivalent address having `scope_id() == 0`, and ['`scope-id`] is an 288 | implementation-defined string representation of the scope identifier.] 289 | 290 | [function_returns If successful, the string representation of the address. 291 | Otherwise `string()`.] 292 | 293 | [endsect] 294 | 295 | [section [^ip::address_v6] static members] 296 | 297 | static constexpr address_v6 any() noexcept; 298 | 299 | [function_returns `address_v6()`.] 300 | 301 | static constexpr address_v6 loopback() noexcept; 302 | 303 | [function_returns An address `a` such that the condition `a.is_loopback()` 304 | holds.] 305 | [endsect] 306 | 307 | [section:ip__address_v6__comparisons [^ip::address_v6] comparisons] 308 | 309 | bool operator==(const address_v6& a, const address_v6& b) noexcept; 310 | 311 | [function_returns `a.to_bytes() == b.to_bytes() && a.scope_id() == 312 | b.scope_id()`.] 313 | 314 | bool operator!=(const address_v6& a, const address_v6& b) noexcept; 315 | 316 | [function_returns `!(a == b)`.] 317 | 318 | bool operator< (const address_v6& a, const address_v6& b) noexcept; 319 | 320 | [function_returns `a.to_bytes() < b.to_bytes() || (!(b.to_bytes() < 321 | a.to_bytes()) && a.scope_id() < b.scope_id())`.] 322 | 323 | bool operator> (const address_v6& a, const address_v6& b) noexcept; 324 | 325 | [function_returns `b < a`.] 326 | 327 | bool operator<=(const address_v6& a, const address_v6& b) noexcept; 328 | 329 | [function_returns `!(b < a)`.] 330 | 331 | bool operator>=(const address_v6& a, const address_v6& b) noexcept; 332 | 333 | [function_returns `!(a < b)`.] 334 | 335 | [endsect] 336 | 337 | [section:ip__address_v6__creation [^ip::address_v6] creation] 338 | 339 | constexpr address_v6 make_address_v6(const address_v6::bytes_type& bytes, 340 | unsigned long scope_id); 341 | 342 | [function_returns `address_v6(bytes, scope_id)`.] 343 | 344 | constexpr address_v6 make_address_v6(v4_mapped_t, const address_v4& a) noexcept; 345 | 346 | [function_returns An `address_v6` object containing the IPv4-mapped IPv6 address 347 | corresponding to the specified IPv4 address, as if computed by the following 348 | method: 349 | `` 350 | address_v4::bytes_type v4b = a.to_bytes(); 351 | bytes_type v6b(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 352 | 0xFF, 0xFF, v4b[0], v4b[1], v4b[2], v4b[3]); 353 | return address_v6(v6b); 354 | ``] 355 | 356 | address_v6 make_address_v6(const char* str); 357 | address_v6 make_address_v6(const char* str, error_code& ec) noexcept; 358 | address_v6 make_address_v6(const string& str); 359 | address_v6 make_address_v6(const string& str, error_code& ec) noexcept; 360 | 361 | [function_effects Converts a string representation of an address into a 362 | corresponding `address_v6` value. The format is either ['`address`] or 363 | ['`address`]`%`['`scope-id`], where ['`address`] is in the format specified by 364 | __POSIX__ __inet_pton__ when invoked with address family `AF_INET6`, and 365 | ['`scope-id`] is an optional string specifying the scope identifier. All 366 | implementations shall accept as ['`scope-id`] a string representation of an 367 | unsigned decimal integer. It is implementation-defined whether alternative 368 | scope identifier representations are permitted. If ['`scope-id`] is not 369 | supplied, an `address_v6` object shall be returned such that `scope_id() == 370 | 0`.] 371 | 372 | [function_returns If successful, an `address_v6` value corresponding to the 373 | string `str`. Otherwise returns `address_v6()`.] 374 | 375 | [endsect] 376 | 377 | [section:ip__address_v6__io [^ip::address_v6] I/O] 378 | 379 | template 380 | basic_ostream& operator<<( 381 | basic_ostream& os, const address_v6& addr); 382 | 383 | [function_effects Outputs the string representation of the address to the 384 | stream, as if it were implemented as follows: 385 | `` 386 | error_code ec; 387 | string s = addr.to_string(ec); 388 | if (ec) 389 | { 390 | if (os.exceptions() & ios_base::failbit) 391 | throw system_error(ec); 392 | else 393 | os.setstate(ios_base::failbit); 394 | } 395 | else 396 | for (string::iterator i = s.begin(); i != s.end(); ++i) 397 | os << os.widen(*i); 398 | ``] 399 | 400 | [function_returns `os`.] 401 | 402 | [endsect] 403 | 404 | [endsect] 405 | -------------------------------------------------------------------------------- /doc/classes/ip__bad_address_cast.qbk: -------------------------------------------------------------------------------- 1 | [section:ip__bad_address_cast Class [^ip::bad_address_cast]] 2 | 3 | namespace std { 4 | namespace experimental { 5 | namespace net { 6 | namespace ip { 7 | 8 | class bad_address_cast : bad_cast 9 | { 10 | public: 11 | virtual const char* what() const noexcept; 12 | }; 13 | 14 | } // namespace ip 15 | } // namespace net 16 | } // namespace experimental 17 | } // namespace std 18 | 19 | Objects of type `bad_address_cast` are thrown by a failed `address_cast`. 20 | 21 | [endsect] 22 | -------------------------------------------------------------------------------- /doc/definitions.qbk: -------------------------------------------------------------------------------- 1 | [section Definitions] 2 | 3 | [section:host_byte_order host byte order] 4 | See section 1.4 of 5 | [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3783.pdf N3783 6 | Network Byte Order Conversion]. 7 | [endsect] 8 | 9 | [section:network_byte_order network byte order] 10 | See section 1.4 of 11 | [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3783.pdf N3783 12 | Network Byte Order Conversion]. 13 | [endsect] 14 | 15 | [endsect] 16 | -------------------------------------------------------------------------------- /doc/error_reporting.qbk: -------------------------------------------------------------------------------- 1 | [section Error reporting] 2 | 3 | Network library functions often provide two overloads, one that throws an 4 | exception to report system errors, and another that sets an `error_code`. 5 | 6 | [std_note This supports two common use cases:[br][br] 7 | 8 | [mdash] Uses where system errors are truly exceptional and indicate a serious 9 | failure. Throwing an exception is the most appropriate response. This is the 10 | preferred default for most everyday programming.[br][br] 11 | 12 | [mdash] Uses where system errors are routine and do not necessarily represent 13 | failure. Returning an error code is the most appropriate response. This allows 14 | application specific error handling, including simply ignoring the 15 | error.[br][br]] 16 | 17 | Functions [*not] having an argument of type `error_code&` report errors as 18 | follows, unless otherwise specified: 19 | 20 | [mdash] When a call by the implementation to an operating system or other 21 | underlying API results in an error that prevents the function from meeting its 22 | specifications, an exception of type `system_error` shall be thrown. 23 | 24 | [mdash] Failure to allocate storage is reported by throwing an exception as 25 | described in the C++ standard (C++14 \[res.on.exception.handling\]). 26 | 27 | [mdash] Destructors throw nothing. 28 | 29 | Functions having an argument of type `error_code&` report errors as follows, 30 | unless otherwise specified: 31 | 32 | [mdash] If a call by the implementation to an operating system or other 33 | underlying API results in an error that prevents the function from meeting its 34 | specifications, the `error_code&` argument is set as appropriate for the 35 | specific error. Otherwise, `clear()` is called on the `error_code&` argument. 36 | 37 | [endsect] 38 | -------------------------------------------------------------------------------- /doc/functions/ip__address_cast.qbk: -------------------------------------------------------------------------------- 1 | [section:ip__address_cast Function [^ip::address_cast]] 2 | 3 | template constexpr T address_cast(const address& a) noexcept(``['see below]``); 4 | 5 | [:This function template shall participate in overload resolution only for the 6 | types `T` listed in the table below.] 7 | 8 | [table template constexpr T address_cast(const address&) effects 9 | [[T][noexcept][remarks]] 10 | [ 11 | [`address`] 12 | [`true`] 13 | [Returns `a`.] 14 | ] 15 | [ 16 | [`address_v4`] 17 | [`false`] 18 | [If `a.is_v4()` is `true`, returns the IP version 4 address specified in the 19 | version-independent address object `a`. Otherwise, throws `bad_address_cast`.] 20 | ] 21 | [ 22 | [`address_v6`] 23 | [`false`] 24 | [If `a.is_v6()` is `true`, returns the IP version 6 address specified in the 25 | version-independent address object `a`. Otherwise, throws `bad_address_cast`.] 26 | ] 27 | ] 28 | 29 | template constexpr T address_cast(const address_v4& a) noexcept(``['see below]``); 30 | 31 | [:This function template shall participate in overload resolution only for the 32 | types `T` listed in the table below.] 33 | 34 | [table template constexpr T address_cast(const address_v4&) effects 35 | [[T][noexcept][remarks]] 36 | [ 37 | [`address`] 38 | [`true`] 39 | [Returns a version-independent `address` object `b` such that `b.is_v4()` 40 | is `true`, `b.is_v6()` is `false`, and `address_cast(b) == a`.] 41 | ] 42 | [ 43 | [`address_v4`] 44 | [`true`] 45 | [Returns `a`.] 46 | ] 47 | [ 48 | [`address_v6`] 49 | [] 50 | [Function overload is deleted.] 51 | ] 52 | ] 53 | 54 | template constexpr T address_cast(const address_v6& a) noexcept(``['see below]``); 55 | 56 | [:This function template shall participate in overload resolution only for the 57 | types `T` listed in the table below.] 58 | 59 | [table template constexpr T address_cast(const address_v6&) effects 60 | [[T][noexcept][remarks]] 61 | [ 62 | [`address`] 63 | [`true`] 64 | [Returns a version-independent `address` object `b` such that `b.is_v4()` 65 | is `false`, `b.is_v6()` is `true`, and `address_cast(b) == a`.] 66 | ] 67 | [ 68 | [`address_v4`] 69 | [] 70 | [Function overload is deleted.] 71 | ] 72 | [ 73 | [`address_v6`] 74 | [`true`] 75 | [Returns `a`.] 76 | ] 77 | ] 78 | 79 | [endsect] 80 | -------------------------------------------------------------------------------- /doc/functions/literals.qbk: -------------------------------------------------------------------------------- 1 | [section:literals Suffixes for address literals] 2 | 3 | This section describes literal suffixes for constructing address literals. The 4 | suffixes `ip`, `ipv4` and `ipv6` denote address values of the corresponding 5 | types `ip::address`, `ip::address_v4` and `ip::address_v6` respectively if they 6 | are applied to string literals. 7 | 8 | [std_example The following code shows some address literals. .. 9 | ``` 10 | using namespace std::experimental::net_literals; 11 | auto addr = "127.0.0.1"ip; 12 | auto v4_addr = "255.255.255.255"ipv4; 13 | auto v6_addr = "::1"ipv6; 14 | ```] 15 | 16 | net::ip::address operator "" ip(const char* str, size_t); 17 | 18 | [function_returns `net::ip::make_address(str)`.] 19 | 20 | net::ip::address_v4 operator "" ipv4(const char* str, size_t); 21 | 22 | [function_returns `net::ip::make_address_v4(str)`.] 23 | 24 | net::ip::address_v6 operator "" ipv6(const char* str, size_t); 25 | 26 | [function_returns `net::ip::make_address_v6(str)`.] 27 | 28 | [endsect] 29 | -------------------------------------------------------------------------------- /doc/headers/network.qbk: -------------------------------------------------------------------------------- 1 | [section Header [^] synopsis] 2 | 3 | namespace std { 4 | namespace experimental { 5 | namespace net { 6 | 7 | // Internet protocol addresses: 8 | 9 | namespace ip { 10 | 11 | struct v4_mapped_t {}; 12 | constexpr v4_mapped_t v4_mapped; 13 | 14 | class ``[link classes.ip__address address]``; 15 | class ``[link classes.ip__address_v4 address_v4]``; 16 | class ``[link classes.ip__address_v6 address_v6]``; 17 | 18 | class ``[link classes.ip__bad_address_cast bad_address_cast]``; 19 | 20 | // ``[link classes.ip__address__comparisons address comparisons]``: 21 | bool operator==(const address&, const address&) noexcept; 22 | bool operator!=(const address&, const address&) noexcept; 23 | bool operator< (const address&, const address&) noexcept; 24 | bool operator> (const address&, const address&) noexcept; 25 | bool operator<=(const address&, const address&) noexcept; 26 | bool operator>=(const address&, const address&) noexcept; 27 | 28 | // ``[link classes.ip__address_v4__comparisons address_v4 comparisons]``: 29 | bool operator==(const address_v4&, const address_v4&) noexcept; 30 | bool operator!=(const address_v4&, const address_v4&) noexcept; 31 | bool operator< (const address_v4&, const address_v4&) noexcept; 32 | bool operator> (const address_v4&, const address_v4&) noexcept; 33 | bool operator<=(const address_v4&, const address_v4&) noexcept; 34 | bool operator>=(const address_v4&, const address_v4&) noexcept; 35 | 36 | // ``[link classes.ip__address_v6__comparisons address_v6 comparisons]``: 37 | bool operator==(const address_v6&, const address_v6&) noexcept; 38 | bool operator!=(const address_v6&, const address_v6&) noexcept; 39 | bool operator< (const address_v6&, const address_v6&) noexcept; 40 | bool operator> (const address_v6&, const address_v6&) noexcept; 41 | bool operator<=(const address_v6&, const address_v6&) noexcept; 42 | bool operator>=(const address_v6&, const address_v6&) noexcept; 43 | 44 | // ``[link classes.ip__address__creation address creation]``: 45 | address make_address(const char*); 46 | address make_address(const char*, error_code&) noexcept; 47 | address make_address(const string&); 48 | address make_address(const string&, error_code&) noexcept; 49 | 50 | // ``[link classes.ip__address_v4__creation address_v4 creation]``: 51 | constexpr address_v4 make_address_v4(const address_v4::bytes_type&); 52 | constexpr address_v4 make_address_v4(unsigned long); 53 | constexpr address_v4 make_address_v4(v4_mapped_t, const address_v6&); 54 | address_v4 make_address_v4(const char*); 55 | address_v4 make_address_v4(const char*, error_code&) noexcept; 56 | address_v4 make_address_v4(const string&); 57 | address_v4 make_address_v4(const string&, error_code&) noexcept; 58 | 59 | // ``[link classes.ip__address_v6__creation address_v6 creation]``: 60 | constexpr address_v6 make_address_v6(const address_v6::bytes_type&, unsigned long = 0); 61 | constexpr address_v6 make_address_v6(v4_mapped_t, const address_v4&) noexcept; 62 | address_v6 make_address_v6(const char*); 63 | address_v6 make_address_v6(const char*, error_code&) noexcept; 64 | address_v6 make_address_v6(const string&); 65 | address_v6 make_address_v6(const string&, error_code&) noexcept; 66 | 67 | // ``[link classes.ip__address__io address I/O]``: 68 | template 69 | basic_ostream& operator<<( 70 | basic_ostream&, const address&); 71 | 72 | // ``[link classes.ip__address_v4__io address_v4 I/O]``: 73 | template 74 | basic_ostream& operator<<( 75 | basic_ostream&, const address_v4&); 76 | 77 | // ``[link classes.ip__address_v6__io address_v6 I/O]``: 78 | template 79 | basic_ostream& operator<<( 80 | basic_ostream&, const address_v6&); 81 | 82 | // ``[link functions.ip__address_cast address conversions]``: 83 | template constexpr T address_cast(const address&) noexcept(``['see below]``); 84 | template constexpr T address_cast(const address_v4&) noexcept(``['see below]``); 85 | template constexpr T address_cast(const address_v6&) noexcept(``['see below]``); 86 | 87 | } // namespace ip 88 | } // namespace net 89 | 90 | // ``[link classes.hash hash support]`` 91 | template struct hash; 92 | template <> struct hash; 93 | template <> struct hash; 94 | template <> struct hash; 95 | 96 | inline namespace literals { 97 | inline namespace net_literals { 98 | 99 | // ``[link functions.literals suffixes for address literals]`` 100 | net::ip::address operator "" ip(const char*, size_t); 101 | net::ip::address_v4 operator "" ipv4(const char*, size_t); 102 | net::ip::address_v6 operator "" ipv6(const char*, size_t); 103 | 104 | } // namespace net_literals 105 | } // namespace literals 106 | } // namespace experimental 107 | } // namespace std 108 | 109 | [endsect] 110 | -------------------------------------------------------------------------------- /doc/proposal.qbk: -------------------------------------------------------------------------------- 1 | [library A Three-Class IP Address Proposal, Revision 1 2 | [quickbook 1.1] 3 | [id ipaddress] 4 | ] 5 | 6 | [/-----------------------------------------------------------------------------] 7 | 8 | [template std_note[text] 9 | \[['Note:] [text] '''—'''['end note]\] 10 | ] 11 | 12 | [template inline_note[text] \[['Note:] [text] '''—'''['end note]\] ] 13 | 14 | [template std_example[text code] 15 | \[['Example:] [text] 16 | [code] 17 | '''—'''['end example]\] 18 | ] 19 | 20 | [template function_block[text] 21 | [:[text]] 22 | ] 23 | 24 | [template function_requires[text] 25 | [:['Requires:] [text]] 26 | ] 27 | 28 | [template function_effects[text] 29 | [:['Effects:] [text]] 30 | ] 31 | 32 | [template function_returns[text] 33 | [:['Returns:] [text]] 34 | ] 35 | 36 | [template function_throws[text] 37 | [:['Throws:] [text]] 38 | ] 39 | 40 | [template function_postconditions[text] 41 | [:['Postconditions:] [text]] 42 | ] 43 | 44 | [template function_complexity[text] 45 | [:['Complexity:] [text]] 46 | ] 47 | 48 | [template function_remarks[text] 49 | [:['Remarks:] [text]] 50 | ] 51 | 52 | [template function_notes[text] 53 | [:['Notes:] [text]] 54 | ] 55 | 56 | [template function_note[text] 57 | [:\[['Note:] [text] '''—'''['end note]\]] 58 | ] 59 | 60 | [template function_example[text] 61 | [:\[['Example:] [text] 62 | '''—'''['end example]\]] 63 | ] 64 | 65 | [template mdash[] '''— '''] 66 | 67 | [/-----------------------------------------------------------------------------] 68 | 69 | [def __POSIX__ /POSIX/] 70 | [def __inet_ntop__ [@http://www.opengroup.org/onlinepubs/000095399/functions/inet_ntop.html `inet_ntop()`]] 71 | [def __inet_pton__ [@http://www.opengroup.org/onlinepubs/000095399/functions/inet_pton.html `inet_pton()`]] 72 | [def __Asio__ [@http://www.boost.org/libs/asio Boost.Asio]] 73 | [def __N2175__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2175.pdf N2175] "Networking Library Proposal for TR2 (Revision 1)"] 74 | [def __dotdotdot__ ...] 75 | 76 | [/-----------------------------------------------------------------------------] 77 | 78 | [template RFC4291[] \[[link ref-RFC4291 RFC4291]\]] 79 | 80 | [/-----------------------------------------------------------------------------] 81 | 82 | [section Overview] 83 | 84 | This proposal describes a three-class design for IP address classes: 85 | 86 | * A vocabulary type, `ip::address`, for use in IP version independent code. 87 | 88 | * An IPv4-specific type `ip::address_v4`. 89 | 90 | * An IPv6-specific type `ip::address_v6`. 91 | 92 | [endsect] 93 | 94 | [/-----------------------------------------------------------------------------] 95 | 96 | [section Motivation and Scope] 97 | 98 | [section Scope] 99 | 100 | This proposal describes only types necessary to support the manipulation of IP 101 | (Internet Protocol) addresses. Other networking facilities, such as sockets and 102 | name resolution, are outside the scope of this proposal. 103 | 104 | [endsect] 105 | 106 | [section Target Audience] 107 | 108 | The proposed interface is primarily intended for use by developers writing 109 | programs with a networking component, and in particular programs that utilise 110 | internet protocols such as TCP and UDP. 111 | 112 | [endsect] 113 | 114 | [section Reference Implementation] 115 | 116 | This proposal is based on the IP address classes in the __Asio__ library. The 117 | proposed text was originally from __N2175__ with small modifications to reflect 118 | enhancements made to __Asio__ since 2007. 119 | 120 | In this revision, the proposed text has been updated to reflect feedback and 121 | discussion from the Bristol 2013 meeting of SG4. A reference implementation of 122 | the proposal is available from [@https://github.com/chriskohlhoff/ip-address 123 | GitHub]. 124 | 125 | [endsect] 126 | 127 | [endsect] 128 | 129 | [/-----------------------------------------------------------------------------] 130 | 131 | [section Impact On the Standard] 132 | 133 | This is a pure library proposal. It does not add any new language features, nor 134 | does it alter any existing standard library headers. 135 | 136 | This library can be implemented using compilers that conform to the C++11 137 | standard. An implementation of this library requires operating system-specific 138 | functions that lie outside the C++11 standard. 139 | 140 | [endsect] 141 | 142 | [/-----------------------------------------------------------------------------] 143 | 144 | [section Design Decisions] 145 | 146 | For more information on the motivating design decisions for the three-class 147 | design, please consult 148 | [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3603.html N3603]. 149 | 150 | In this section we list some of the additional proposed changes that were 151 | considered but rejected. The changes incorporated since N3603 are described 152 | [link ipaddress.changes at the end]. 153 | 154 | [section Overloads of hton and ntoh] 155 | 156 | One suggestion was that the proposal should include overloads of `hton` and 157 | `ntoh` for the address types. The motivating use case was that address objects 158 | may be used directly as part of standard-layout aggregates that are ultimately 159 | intended for network transmission. 160 | 161 | This change was rejected on the basis that the applying `hton` to a class type 162 | (as opposed to a simple integer) may result in an object that is in an invalid 163 | or nonsensical state. As a matter of style, the author feels that the address 164 | types should be treated as abstractions without necessarily forcing a 165 | particular internal implementation. 166 | 167 | The addresses' `to_bytes()` member functions can already be used to obtain a 168 | representation of the address in network byte order. To further aid the 169 | motivating use case, the `bytes_type` types have been changed to be [link 170 | ipaddress.bytes_type unique types]. 171 | 172 | [endsect] 173 | 174 | [section Specialisation of less<>] 175 | 176 | Another suggestion was that the address types should specialise `std::less<>` 177 | rather than provide `operator<` and friends. This change was rejected since it 178 | would appear to render the address types incompatible with other standard 179 | library types, such as `std::tuple<>`, which apply `operator<` to their elements. 180 | 181 | [endsect] 182 | 183 | [endsect] 184 | 185 | [/-----------------------------------------------------------------------------] 186 | 187 | [section Further Work] 188 | 189 | [section Address Iteration] 190 | 191 | It has been suggested in the SG4 discussion forum that the address classes 192 | include the ability to determine the predecessor or successor of an address. By 193 | this we mean that given an address 1.2.3.4, the predecessor address is 1.2.3.3 194 | and the successor is 1.2.3.5. 195 | 196 | The author feels that this feature is not a core responsibility of the address 197 | classes, but if it is desired it can instead be supported by a richer 198 | range-based interface. The following is a sketch of this approach: 199 | 200 | class address_iterator_v4 201 | { 202 | public: 203 | typedef std::ptrdiff_t difference_type; 204 | typedef address_v4 value_type; 205 | typedef const address_v4* pointer; 206 | typedef const address_v4& reference; 207 | typedef std::bidirectional_iterator_tag iterator_category; 208 | 209 | explicit address_iterator_v4(const address_v4& addr); 210 | 211 | const address_v4& operator*() const; 212 | const address_v4* operator->() const; 213 | 214 | address_iterator_v4& operator++(); 215 | address_iterator_v4 operator++(int); 216 | 217 | address_iterator_v4& operator--(); 218 | address_iterator_v4 operator--(int); 219 | 220 | friend bool operator==(const address_iterator_v4& a, const address_iterator_v4& b); 221 | friend bool operator!=(const address_iterator_v4& a, const address_iterator_v4& b); 222 | 223 | private: 224 | // ... 225 | }; 226 | 227 | class address_range_v4 228 | { 229 | public: 230 | address_range_v4(); 231 | explicit address_range_v4(const address_v4& addr); 232 | explicit address_range_v4(const address_v4& addr, const address_v4& mask); 233 | 234 | address_v4 network() const; 235 | address_v4 netmask() const; 236 | address_v4 broadcast() const; 237 | 238 | typedef address_iterator_v4 iterator; 239 | iterator begin() const; 240 | iterator end() const; 241 | iterator find(const address_v4& addr) const; 242 | 243 | private: 244 | // ... 245 | }; 246 | 247 | This may be used as in the following example: 248 | 249 | address_range_v4 range( 250 | make_address_v4("192.168.1.0"), 251 | make_address_v4("255.255.255.0")); 252 | 253 | for (auto a: range) 254 | std::cout << a << std::endl; 255 | 256 | std::cout << "---" << std::endl; 257 | 258 | std::for_each( 259 | range.find(make_address_v4("192.168.1.250")), 260 | range.end(), 261 | [](address_v4 a) { std::cout << a << std::endl; }); 262 | 263 | If SG4 determines that this feature is desirable, it may be added to this 264 | proposal or developed as a separate proposal. The author favours the latter. 265 | 266 | [endsect] 267 | 268 | [endsect] 269 | 270 | [/-----------------------------------------------------------------------------] 271 | 272 | [section Proposed Text] 273 | 274 | [include:definitions definitions.qbk] 275 | [include:error_reporting error_reporting.qbk] 276 | 277 | [section:internet_protocol Internet protocol addresses] 278 | 279 | This clause describes components that C++ programs may use to manipulate IP 280 | addresses. 281 | 282 | [include:headers headers/network.qbk] 283 | 284 | [include:classes classes/ip__address.qbk] 285 | [include:classes classes/ip__address_v4.qbk] 286 | [include:classes classes/ip__address_v6.qbk] 287 | [include:classes classes/ip__bad_address_cast.qbk] 288 | [include:functions functions/ip__address_cast.qbk] 289 | [include:classes classes/hash.qbk] 290 | [include:functions functions/literals.qbk] 291 | 292 | [endsect] 293 | 294 | [endsect] 295 | 296 | [/-----------------------------------------------------------------------------] 297 | 298 | [section:changes Changes in This Revision] 299 | 300 | In this revision of the proposal, we include changes made based on feedback and 301 | discussion from the 2013 meeting of SG4 at Bristol, where N3603 was discussed. 302 | 303 | [section Namespace] 304 | 305 | This revision moves the proposed types and functions from the `std::` namespace 306 | to `std::experimental::`. 307 | 308 | [endsect] 309 | 310 | [section A Version-Independent Vocabulary Type] 311 | 312 | The `ip::address` class has been modified so that the version-specific types do 313 | not appear in its interface. An approach based on the `any` class has been 314 | adopted (see Library Fundamentals working draft), and address types may be 315 | explicitly converted using the `address_cast<>` function. The version-specific 316 | types are implicitly convertible to `ip::address` via a template constructor. 317 | 318 | For example: 319 | 320 | address_v4 a; 321 | address b = a; // ok, implicit conversion 322 | address c = address_cast
(a); // ok, explicit conversion 323 | address_v4 d = address_cast(b); // ok, explicit conversion 324 | address_v6 e = address_cast(b); // invalid, throws bad_address_cast 325 | 326 | [endsect] 327 | 328 | [section Use of noexcept] 329 | 330 | Many functions have now been marked `noexcept`. 331 | 332 | [endsect] 333 | 334 | [section Explicit Creation from Strings] 335 | 336 | This replaces the `from_string()` static member functions with new free 337 | functions `make_address()`, `make_address_v4()` and `make_address_v6()`. These 338 | functions allow explicit creation of the address types from strings and other 339 | types, such as an array of bytes or an integer in host byte order. For example, 340 | one overload throws an exception on failure: 341 | 342 | address_v4 a = make_address_v4("127.0.0.1"); // succeeds 343 | address_v4 b = make_address_v4("::1"); // throws 344 | 345 | and another overload provides a non-throwing alternative: 346 | 347 | error_code ec; 348 | address_v4 b = make_address_v4("127.0.0.1", ec); // succeeds, clears ec 349 | address_v4 b = make_address_v4("::1", ec); // sets ec 350 | 351 | An explicit template constructor has been added to also support this style of 352 | use: 353 | 354 | address c("127.0.0.1"); 355 | 356 | This constructor simply forwards the arguments to the appropriate 357 | `make_address()` overload. 358 | 359 | [endsect] 360 | 361 | [section String Literals] 362 | 363 | Support for IP address literals has been included. For example: 364 | 365 | using namespace std::experimental::net_literals; 366 | auto addr = "127.0.0.1"ip; 367 | auto v4_addr = "255.255.255.255"ipv4; 368 | auto v6_addr = "::1"ipv6; 369 | 370 | [endsect] 371 | 372 | [section:bytes_type Strongly-Typed Byte Representations] 373 | 374 | The nested typedefs `bytes_type` have been changed to be unique standard-layout 375 | types. Objects of type `bytes_type` are implicitly convertible to the 376 | corresponding address class. This is intended to support the following use 377 | case, where the byte representations of addresses are included as part of a 378 | larger standard-layout structure, such as a packet definition: 379 | 380 | struct header 381 | { 382 | address_v4::bytes_type from; 383 | address_v4::bytes_type to; 384 | // ... 385 | }; 386 | 387 | struct message 388 | { 389 | header hdr; 390 | // ... 391 | }; 392 | 393 | // ... 394 | 395 | address_v4 old_address = "1.2.3.4"ipv4; 396 | address_v4 new_address = "4.3.2.1"ipv4; 397 | 398 | message m; 399 | receive_message(m); // e.g. reads bytes from a socket 400 | if (m.hdr.to == old_address) 401 | m.hdr.to = new_address.to_bytes(); 402 | 403 | [endsect] 404 | 405 | [section Use of constexpr] 406 | 407 | The `constexpr` keyword has been applied to some of the functions in the 408 | proposal. The rationale for this change is that many of the equivalent 409 | __POSIX__ macros can be used in constant expressions. 410 | 411 | [endsect] 412 | 413 | [section Make Default-Constructed address Invalid] 414 | 415 | A default-constructed `address` object now represents an invalid address that 416 | is neither IPv4 nor IPv6. Any attempt to `address_cast` it to another type will 417 | result in a `bad_address_cast` exception. 418 | 419 | [endsect] 420 | 421 | [section Removed address_v4::netmask] 422 | 423 | The `ip::address_v4::netmask` function has been removed as it is not possible 424 | to give the correct answer, given only an arbitrary IP address, without access 425 | to the routing table. 426 | 427 | [endsect] 428 | 429 | [endsect] 430 | 431 | [/-----------------------------------------------------------------------------] 432 | 433 | [section Acknowledgements] 434 | 435 | The author would like to thank Arash Partow, Jamie Allsop, James Anderson and 436 | Kyle Kloepper for their feedback and suggestions. 437 | 438 | [endsect] 439 | 440 | [/-----------------------------------------------------------------------------] 441 | 442 | [section References] 443 | 444 | [#ref-RFC4291] \[RFC4291\] Hinden, R. and Deering, S., 445 | ['RFC 4291: Internet Protocol Version 6 (IPv6) Addressing Architecture], 2006, 446 | [@http://www.ietf.org/rfc/rfc4291.txt]. 447 | 448 | [endsect] 449 | -------------------------------------------------------------------------------- /include/network: -------------------------------------------------------------------------------- 1 | // 2 | // network 3 | // ~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_NETWORK_HEADER_FILE 12 | #define STDNET_NETWORK_HEADER_FILE 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/ip/fwd.hpp" 19 | #include "std/net/ip/address.hpp" 20 | #include "std/net/ip/address_v4.hpp" 21 | #include "std/net/ip/address_v6.hpp" 22 | #include "std/net/ip/address_cast.hpp" 23 | #include "std/net/literals.hpp" 24 | 25 | #endif // STDNET_NETWORK_HEADER_FILE 26 | -------------------------------------------------------------------------------- /include/std/net/detail/impl/socket_ops.ipp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/impl/socket_ops.ipp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_SOCKET_OPS_IPP 12 | #define STDNET_DETAIL_SOCKET_OPS_IPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include "std/net/detail/socket_ops.hpp" 26 | #include "std/net/detail/system_errors.hpp" 27 | 28 | #include "std/net/detail/push_options.hpp" 29 | 30 | namespace std { 31 | namespace experimental { 32 | namespace net { 33 | namespace detail { 34 | namespace socket_ops { 35 | 36 | #if defined(__hpux) 37 | // HP-UX doesn't declare these functions extern "C", so they are declared again 38 | // here to avoid linker errors about undefined symbols. 39 | extern "C" char* if_indextoname(unsigned int, char*); 40 | extern "C" unsigned int if_nametoindex(const char*); 41 | #endif // defined(__hpux) 42 | 43 | inline void clear_last_error() 44 | { 45 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 46 | WSASetLastError(0); 47 | #else 48 | errno = 0; 49 | #endif 50 | } 51 | 52 | template 53 | inline ReturnType error_wrapper(ReturnType return_value, 54 | std::error_code& ec) 55 | { 56 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 57 | ec = std::error_code(WSAGetLastError(), 58 | std::experimental::net::detail::syserrc::system_category()); 59 | #else 60 | ec = std::error_code(errno, 61 | std::experimental::net::detail::syserrc::system_category()); 62 | #endif 63 | return return_value; 64 | } 65 | 66 | const char* inet_ntop(int af, const void* src, char* dest, size_t length, 67 | unsigned long scope_id, std::error_code& ec) 68 | { 69 | clear_last_error(); 70 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 71 | using namespace std; // For memcpy. 72 | 73 | if (af != AF_INET && af != AF_INET6) 74 | { 75 | ec = std::experimental::net::detail::syserrc::address_family_not_supported; 76 | return 0; 77 | } 78 | 79 | union 80 | { 81 | socket_addr_type base; 82 | sockaddr_storage_type storage; 83 | sockaddr_in4_type v4; 84 | sockaddr_in6_type v6; 85 | } address; 86 | DWORD address_length; 87 | if (af == AF_INET) 88 | { 89 | address_length = sizeof(sockaddr_in4_type); 90 | address.v4.sin_family = AF_INET; 91 | address.v4.sin_port = 0; 92 | memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type)); 93 | } 94 | else // AF_INET6 95 | { 96 | address_length = sizeof(sockaddr_in6_type); 97 | address.v6.sin6_family = AF_INET6; 98 | address.v6.sin6_port = 0; 99 | address.v6.sin6_flowinfo = 0; 100 | address.v6.sin6_scope_id = scope_id; 101 | memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type)); 102 | } 103 | 104 | DWORD string_length = static_cast(length); 105 | #if defined(STDNET_NO_ANSI_APIS) 106 | LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR)); 107 | int result = error_wrapper(::WSAAddressToStringW(&address.base, 108 | address_length, 0, string_buffer, &string_length), ec); 109 | ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1, dest, length, 0, 0); 110 | #else 111 | int result = error_wrapper(::WSAAddressToStringA( 112 | &address.base, address_length, 0, dest, &string_length), ec); 113 | #endif 114 | 115 | // Windows may set error code on success. 116 | if (result != socket_error_retval) 117 | ec = std::error_code(); 118 | 119 | // Windows may not set an error code on failure. 120 | else if (result == socket_error_retval && !ec) 121 | ec = std::experimental::net::detail::syserrc::invalid_argument; 122 | 123 | return result == socket_error_retval ? 0 : dest; 124 | #else // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 125 | const char* result = error_wrapper(::inet_ntop( 126 | af, src, dest, static_cast(length)), ec); 127 | if (result == 0 && !ec) 128 | ec = std::experimental::net::detail::syserrc::invalid_argument; 129 | if (result != 0 && af == AF_INET6 && scope_id != 0) 130 | { 131 | using namespace std; // For strcat and sprintf. 132 | char if_name[IF_NAMESIZE + 1] = "%"; 133 | const in6_addr_type* ipv6_address = static_cast(src); 134 | bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe) 135 | && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80)); 136 | if (!is_link_local 137 | || if_indextoname(static_cast(scope_id), if_name + 1) == 0) 138 | sprintf(if_name + 1, "%lu", scope_id); 139 | strcat(dest, if_name); 140 | } 141 | return result; 142 | #endif // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 143 | } 144 | 145 | int inet_pton(int af, const char* src, void* dest, 146 | unsigned long* scope_id, std::error_code& ec) 147 | { 148 | clear_last_error(); 149 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 150 | using namespace std; // For memcpy and strcmp. 151 | 152 | if (af != AF_INET && af != AF_INET6) 153 | { 154 | ec = std::experimental::net::detail::syserrc::address_family_not_supported; 155 | return -1; 156 | } 157 | 158 | union 159 | { 160 | socket_addr_type base; 161 | sockaddr_storage_type storage; 162 | sockaddr_in4_type v4; 163 | sockaddr_in6_type v6; 164 | } address; 165 | int address_length = sizeof(sockaddr_storage_type); 166 | #if defined(STDNET_NO_ANSI_APIS) 167 | int num_wide_chars = strlen(src) + 1; 168 | LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR)); 169 | ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars); 170 | int result = error_wrapper(::WSAStringToAddressW( 171 | wide_buffer, af, 0, &address.base, &address_length), ec); 172 | #else 173 | int result = error_wrapper(::WSAStringToAddressA( 174 | const_cast(src), af, 0, &address.base, &address_length), ec); 175 | #endif 176 | 177 | if (af == AF_INET) 178 | { 179 | if (result != socket_error_retval) 180 | { 181 | memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type)); 182 | ec = std::error_code(); 183 | } 184 | else if (strcmp(src, "255.255.255.255") == 0) 185 | { 186 | static_cast(dest)->s_addr = INADDR_NONE; 187 | ec = std::error_code(); 188 | } 189 | } 190 | else // AF_INET6 191 | { 192 | if (result != socket_error_retval) 193 | { 194 | memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type)); 195 | if (scope_id) 196 | *scope_id = address.v6.sin6_scope_id; 197 | ec = std::error_code(); 198 | } 199 | } 200 | 201 | // Windows may not set an error code on failure. 202 | if (result == socket_error_retval && !ec) 203 | ec = std::experimental::net::detail::syserrc::invalid_argument; 204 | 205 | if (result != socket_error_retval) 206 | ec = std::error_code(); 207 | 208 | return result == socket_error_retval ? -1 : 1; 209 | #else // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 210 | int result = error_wrapper(::inet_pton(af, src, dest), ec); 211 | if (result <= 0 && !ec) 212 | ec = std::experimental::net::detail::syserrc::invalid_argument; 213 | if (result > 0 && af == AF_INET6 && scope_id) 214 | { 215 | using namespace std; // For strchr and atoi. 216 | *scope_id = 0; 217 | if (const char* if_name = strchr(src, '%')) 218 | { 219 | in6_addr_type* ipv6_address = static_cast(dest); 220 | bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe) 221 | && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80)); 222 | if (is_link_local) 223 | *scope_id = if_nametoindex(if_name + 1); 224 | if (*scope_id == 0) 225 | *scope_id = atoi(if_name + 1); 226 | } 227 | } 228 | return result; 229 | #endif // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 230 | } 231 | 232 | u_long_type network_to_host_long(u_long_type value) 233 | { 234 | return ntohl(value); 235 | } 236 | 237 | u_long_type host_to_network_long(u_long_type value) 238 | { 239 | return htonl(value); 240 | } 241 | 242 | u_short_type network_to_host_short(u_short_type value) 243 | { 244 | return ntohs(value); 245 | } 246 | 247 | u_short_type host_to_network_short(u_short_type value) 248 | { 249 | return htons(value); 250 | } 251 | 252 | } // namespace socket_ops 253 | } // namespace detail 254 | } // namespace net 255 | } // namespace experimental 256 | } // namespace std 257 | 258 | #include "std/net/detail/pop_options.hpp" 259 | 260 | #endif // STDNET_DETAIL_SOCKET_OPS_IPP 261 | -------------------------------------------------------------------------------- /include/std/net/detail/impl/system_errors.ipp: -------------------------------------------------------------------------------- 1 | // 2 | // impl/system_errors.ipp 3 | // ~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_IMPL_SYSTEM_ERRORS_IPP 12 | #define STDNET_DETAIL_IMPL_SYSTEM_ERRORS_IPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include "std/net/detail/local_free_on_block_exit.hpp" 20 | #include "std/net/detail/system_errors.hpp" 21 | 22 | #include "std/net/detail/push_options.hpp" 23 | 24 | namespace std { 25 | namespace experimental { 26 | namespace net { 27 | namespace detail { 28 | namespace syserrc { 29 | 30 | class system_category : public std::error_category 31 | { 32 | public: 33 | const char* name() const STDNET_ERROR_CATEGORY_NOEXCEPT 34 | { 35 | return "std.net.system"; 36 | } 37 | 38 | std::string message(int value) const 39 | { 40 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 41 | char* msg = 0; 42 | DWORD length = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER 43 | | FORMAT_MESSAGE_FROM_SYSTEM 44 | | FORMAT_MESSAGE_IGNORE_INSERTS, 0, value, 45 | MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&msg, 0, 0); 46 | detail::local_free_on_block_exit local_free_obj(msg); 47 | if (length && msg[length - 1] == '\n') 48 | msg[--length] = '\0'; 49 | if (length && msg[length - 1] == '\r') 50 | msg[--length] = '\0'; 51 | if (length) 52 | return msg; 53 | else 54 | return "std.net.system error"; 55 | #else // defined(STDNET_WINDOWS) 56 | #if !defined(__sun) 57 | if (value == ECANCELED) 58 | return "Operation aborted."; 59 | #endif // !defined(__sun) 60 | #if defined(__sun) || defined(__QNX__) || defined(__SYMBIAN32__) 61 | using namespace std; 62 | return strerror(value); 63 | #elif defined(__MACH__) && defined(__APPLE__) \ 64 | || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) \ 65 | || defined(_AIX) || defined(__hpux) || defined(__osf__) \ 66 | || defined(__ANDROID__) 67 | char buf[256] = ""; 68 | using namespace std; 69 | strerror_r(value, buf, sizeof(buf)); 70 | return buf; 71 | #else 72 | char buf[256] = ""; 73 | return strerror_r(value, buf, sizeof(buf)); 74 | #endif 75 | #endif // defined(STDNET_WINDOWS) 76 | } 77 | }; 78 | 79 | } // namespace syserrc 80 | 81 | const std::error_category& system_category() 82 | { 83 | static syserrc::system_category instance; 84 | return instance; 85 | } 86 | 87 | } // namespace detail 88 | } // namespace net 89 | } // namespace experimental 90 | } // namespace std 91 | 92 | #include "std/net/detail/pop_options.hpp" 93 | 94 | #endif // STDNET_DETAIL_IMPL_SYSTEM_ERRORS_IPP 95 | -------------------------------------------------------------------------------- /include/std/net/detail/impl/throw_error.ipp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/impl/throw_error.ipp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_IMPL_THROW_ERROR_IPP 12 | #define STDNET_DETAIL_IMPL_THROW_ERROR_IPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include "std/net/detail/throw_error.hpp" 21 | #include "std/net/detail/throw_exception.hpp" 22 | 23 | #include "std/net/detail/push_options.hpp" 24 | 25 | namespace std { 26 | namespace experimental { 27 | namespace net { 28 | namespace detail { 29 | 30 | void do_throw_error(const std::error_code& err) 31 | { 32 | std::system_error e(err); 33 | std::experimental::net::detail::throw_exception(e); 34 | } 35 | 36 | void do_throw_error(const std::error_code& err, const char* location) 37 | { 38 | std::system_error e(err, location); 39 | std::experimental::net::detail::throw_exception(e); 40 | } 41 | 42 | } // namespace detail 43 | } // namespace net 44 | } // namespace experimental 45 | } // namespace std 46 | 47 | #include "std/net/detail/pop_options.hpp" 48 | 49 | #endif // STDNET_DETAIL_IMPL_THROW_ERROR_IPP 50 | -------------------------------------------------------------------------------- /include/std/net/detail/impl/winsock_init.ipp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/impl/winsock_init.ipp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_IMPL_WINSOCK_INIT_IPP 12 | #define STDNET_DETAIL_IMPL_WINSOCK_INIT_IPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | 20 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 21 | 22 | #include "std/net/detail/socket_types.hpp" 23 | #include "std/net/detail/system_errors.hpp" 24 | #include "std/net/detail/winsock_init.hpp" 25 | #include "std/net/detail/throw_error.hpp" 26 | 27 | #include "std/net/detail/push_options.hpp" 28 | 29 | namespace std { 30 | namespace experimental { 31 | namespace net { 32 | namespace detail { 33 | 34 | void winsock_init_base::startup(data& d, 35 | unsigned char major, unsigned char minor) 36 | { 37 | if (::InterlockedIncrement(&d.init_count_) == 1) 38 | { 39 | WSADATA wsa_data; 40 | long result = ::WSAStartup(MAKEWORD(major, minor), &wsa_data); 41 | ::InterlockedExchange(&d.result_, result); 42 | } 43 | } 44 | 45 | void winsock_init_base::cleanup(data& d) 46 | { 47 | if (::InterlockedDecrement(&d.init_count_) == 0) 48 | { 49 | ::WSACleanup(); 50 | } 51 | } 52 | 53 | void winsock_init_base::throw_on_error(data& d) 54 | { 55 | long result = ::InterlockedExchangeAdd(&d.result_, 0); 56 | if (result != 0) 57 | { 58 | std::error_code ec(result, 59 | std::experimental::net::detail::system_category()); 60 | std::experimental::net::detail::throw_error(ec, "winsock"); 61 | } 62 | } 63 | 64 | } // namespace detail 65 | } // namespace net 66 | } // namespace experimental 67 | } // namespace std 68 | 69 | #include "std/net/detail/pop_options.hpp" 70 | 71 | #endif // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 72 | 73 | #endif // STDNET_DETAIL_IMPL_WINSOCK_INIT_IPP 74 | -------------------------------------------------------------------------------- /include/std/net/detail/local_free_on_block_exit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/local_free_on_block_exit.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP 12 | #define STDNET_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | 20 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 21 | 22 | #include "std/net/detail/socket_types.hpp" 23 | 24 | #include "std/net/detail/push_options.hpp" 25 | 26 | namespace std { 27 | namespace experimental { 28 | namespace net { 29 | namespace detail { 30 | 31 | class local_free_on_block_exit 32 | { 33 | public: 34 | // Constructor blocks all signals for the calling thread. 35 | explicit local_free_on_block_exit(void* p) 36 | : p_(p) 37 | { 38 | } 39 | 40 | // Destructor restores the previous signal mask. 41 | ~local_free_on_block_exit() 42 | { 43 | ::LocalFree(p_); 44 | } 45 | 46 | private: 47 | // Disallow copying and assignemnt. 48 | local_free_on_block_exit(const local_free_on_block_exit&); 49 | local_free_on_block_exit& operator=(const local_free_on_block_exit&); 50 | 51 | void* p_; 52 | }; 53 | 54 | } // namespace detail 55 | } // namespace net 56 | } // namespace experimental 57 | } // namespace std 58 | 59 | #include "std/net/detail/pop_options.hpp" 60 | 61 | #endif // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 62 | 63 | #endif // STDNET_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP 64 | -------------------------------------------------------------------------------- /include/std/net/detail/old_win_sdk_compat.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/old_win_sdk_compat.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_OLD_WIN_SDK_COMPAT_HPP 12 | #define STDNET_DETAIL_OLD_WIN_SDK_COMPAT_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | 20 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 21 | 22 | // Guess whether we are building against on old Platform SDK. 23 | #if !defined(IN6ADDR_ANY_INIT) 24 | #define STDNET_HAS_OLD_WIN_SDK 1 25 | #endif // !defined(IN6ADDR_ANY_INIT) 26 | 27 | #if defined(STDNET_HAS_OLD_WIN_SDK) 28 | 29 | // Emulation of types that are missing from old Platform SDKs. 30 | // 31 | // N.B. this emulation is also used if building for a Windows 2000 target with 32 | // a recent (i.e. Vista or later) SDK, as the SDK does not provide IPv6 support 33 | // in that case. 34 | 35 | #include "std/net/detail/push_options.hpp" 36 | 37 | namespace std { 38 | namespace experimental { 39 | namespace net { 40 | namespace detail { 41 | 42 | enum 43 | { 44 | sockaddr_storage_maxsize = 128, // Maximum size. 45 | sockaddr_storage_alignsize = (sizeof(__int64)), // Desired alignment. 46 | sockaddr_storage_pad1size = (sockaddr_storage_alignsize - sizeof(short)), 47 | sockaddr_storage_pad2size = (sockaddr_storage_maxsize - 48 | (sizeof(short) + sockaddr_storage_pad1size + sockaddr_storage_alignsize)) 49 | }; 50 | 51 | struct sockaddr_storage_emulation 52 | { 53 | short ss_family; 54 | char __ss_pad1[sockaddr_storage_pad1size]; 55 | __int64 __ss_align; 56 | char __ss_pad2[sockaddr_storage_pad2size]; 57 | }; 58 | 59 | struct in6_addr_emulation 60 | { 61 | union 62 | { 63 | u_char Byte[16]; 64 | u_short Word[8]; 65 | } u; 66 | }; 67 | 68 | #if !defined(s6_addr) 69 | # define _S6_un u 70 | # define _S6_u8 Byte 71 | # define s6_addr _S6_un._S6_u8 72 | #endif // !defined(s6_addr) 73 | 74 | struct sockaddr_in6_emulation 75 | { 76 | short sin6_family; 77 | u_short sin6_port; 78 | u_long sin6_flowinfo; 79 | in6_addr_emulation sin6_addr; 80 | u_long sin6_scope_id; 81 | }; 82 | 83 | struct ipv6_mreq_emulation 84 | { 85 | in6_addr_emulation ipv6mr_multiaddr; 86 | unsigned int ipv6mr_interface; 87 | }; 88 | 89 | struct addrinfo_emulation 90 | { 91 | int ai_flags; 92 | int ai_family; 93 | int ai_socktype; 94 | int ai_protocol; 95 | size_t ai_addrlen; 96 | char* ai_canonname; 97 | sockaddr* ai_addr; 98 | addrinfo_emulation* ai_next; 99 | }; 100 | 101 | #if !defined(AI_PASSIVE) 102 | # define AI_PASSIVE 0x1 103 | #endif 104 | 105 | #if !defined(AI_CANONNAME) 106 | # define AI_CANONNAME 0x2 107 | #endif 108 | 109 | #if !defined(AI_NUMERICHOST) 110 | # define AI_NUMERICHOST 0x4 111 | #endif 112 | 113 | #if !defined(EAI_AGAIN) 114 | # define EAI_AGAIN WSATRY_AGAIN 115 | #endif 116 | 117 | #if !defined(EAI_BADFLAGS) 118 | # define EAI_BADFLAGS WSAEINVAL 119 | #endif 120 | 121 | #if !defined(EAI_FAIL) 122 | # define EAI_FAIL WSANO_RECOVERY 123 | #endif 124 | 125 | #if !defined(EAI_FAMILY) 126 | # define EAI_FAMILY WSAEAFNOSUPPORT 127 | #endif 128 | 129 | #if !defined(EAI_MEMORY) 130 | # define EAI_MEMORY WSA_NOT_ENOUGH_MEMORY 131 | #endif 132 | 133 | #if !defined(EAI_NODATA) 134 | # define EAI_NODATA WSANO_DATA 135 | #endif 136 | 137 | #if !defined(EAI_NONAME) 138 | # define EAI_NONAME WSAHOST_NOT_FOUND 139 | #endif 140 | 141 | #if !defined(EAI_SERVICE) 142 | # define EAI_SERVICE WSATYPE_NOT_FOUND 143 | #endif 144 | 145 | #if !defined(EAI_SOCKTYPE) 146 | # define EAI_SOCKTYPE WSAESOCKTNOSUPPORT 147 | #endif 148 | 149 | #if !defined(NI_NOFQDN) 150 | # define NI_NOFQDN 0x01 151 | #endif 152 | 153 | #if !defined(NI_NUMERICHOST) 154 | # define NI_NUMERICHOST 0x02 155 | #endif 156 | 157 | #if !defined(NI_NAMEREQD) 158 | # define NI_NAMEREQD 0x04 159 | #endif 160 | 161 | #if !defined(NI_NUMERICSERV) 162 | # define NI_NUMERICSERV 0x08 163 | #endif 164 | 165 | #if !defined(NI_DGRAM) 166 | # define NI_DGRAM 0x10 167 | #endif 168 | 169 | #if !defined(IPPROTO_IPV6) 170 | # define IPPROTO_IPV6 41 171 | #endif 172 | 173 | #if !defined(IPV6_UNICAST_HOPS) 174 | # define IPV6_UNICAST_HOPS 4 175 | #endif 176 | 177 | #if !defined(IPV6_MULTICAST_IF) 178 | # define IPV6_MULTICAST_IF 9 179 | #endif 180 | 181 | #if !defined(IPV6_MULTICAST_HOPS) 182 | # define IPV6_MULTICAST_HOPS 10 183 | #endif 184 | 185 | #if !defined(IPV6_MULTICAST_LOOP) 186 | # define IPV6_MULTICAST_LOOP 11 187 | #endif 188 | 189 | #if !defined(IPV6_JOIN_GROUP) 190 | # define IPV6_JOIN_GROUP 12 191 | #endif 192 | 193 | #if !defined(IPV6_LEAVE_GROUP) 194 | # define IPV6_LEAVE_GROUP 13 195 | #endif 196 | 197 | } // namespace detail 198 | } // namespace net 199 | } // namespace experimental 200 | } // namespace std 201 | 202 | #include "std/net/detail/pop_options.hpp" 203 | 204 | #endif // defined(STDNET_HAS_OLD_WIN_SDK) 205 | 206 | // Even newer Platform SDKs that support IPv6 may not define IPV6_V6ONLY. 207 | #if !defined(IPV6_V6ONLY) 208 | # define IPV6_V6ONLY 27 209 | #endif 210 | 211 | // Some SDKs (e.g. Windows CE) don't define IPPROTO_ICMPV6. 212 | #if !defined(IPPROTO_ICMPV6) 213 | # define IPPROTO_ICMPV6 58 214 | #endif 215 | 216 | #endif // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 217 | 218 | #endif // STDNET_DETAIL_OLD_WIN_SDK_COMPAT_HPP 219 | -------------------------------------------------------------------------------- /include/std/net/detail/pop_options.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/pop_options.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | // No header guard 12 | 13 | #if defined(__COMO__) 14 | 15 | // Comeau C++ 16 | 17 | #elif defined(__DMC__) 18 | 19 | // Digital Mars C++ 20 | 21 | #elif defined(__INTEL_COMPILER) || defined(__ICL) \ 22 | || defined(__ICC) || defined(__ECC) 23 | 24 | // Intel C++ 25 | 26 | #elif defined(__GNUC__) 27 | 28 | // GNU C++ 29 | 30 | # if defined(__MINGW32__) || defined(__CYGWIN__) 31 | # pragma pack (pop) 32 | # endif 33 | 34 | # if defined(__OBJC__) 35 | # if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1) 36 | # if defined(STDNET_OBJC_WORKAROUND) 37 | # undef Protocol 38 | # undef id 39 | # undef STDNET_OBJC_WORKAROUND 40 | # endif 41 | # endif 42 | # endif 43 | 44 | #elif defined(__KCC) 45 | 46 | // Kai C++ 47 | 48 | #elif defined(__sgi) 49 | 50 | // SGI MIPSpro C++ 51 | 52 | #elif defined(__DECCXX) 53 | 54 | // Compaq Tru64 Unix cxx 55 | 56 | #elif defined(__ghs) 57 | 58 | // Greenhills C++ 59 | 60 | #elif defined(__BORLANDC__) 61 | 62 | // Borland C++ 63 | 64 | # pragma option pop 65 | # pragma nopushoptwarn 66 | # pragma nopackwarning 67 | 68 | #elif defined(__MWERKS__) 69 | 70 | // Metrowerks CodeWarrior 71 | 72 | #elif defined(__SUNPRO_CC) 73 | 74 | // Sun Workshop Compiler C++ 75 | 76 | #elif defined(__HP_aCC) 77 | 78 | // HP aCC 79 | 80 | #elif defined(__MRC__) || defined(__SC__) 81 | 82 | // MPW MrCpp or SCpp 83 | 84 | #elif defined(__IBMCPP__) 85 | 86 | // IBM Visual Age 87 | 88 | #elif defined(_MSC_VER) 89 | 90 | // Microsoft Visual C++ 91 | // 92 | // Must remain the last #elif since some other vendors (Metrowerks, for example) 93 | // also #define _MSC_VER 94 | 95 | # pragma warning (pop) 96 | # pragma pack (pop) 97 | 98 | #endif 99 | -------------------------------------------------------------------------------- /include/std/net/detail/push_options.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/push_options.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | // No header guard 12 | 13 | #if defined(__COMO__) 14 | 15 | // Comeau C++ 16 | 17 | #elif defined(__DMC__) 18 | 19 | // Digital Mars C++ 20 | 21 | #elif defined(__INTEL_COMPILER) || defined(__ICL) \ 22 | || defined(__ICC) || defined(__ECC) 23 | 24 | // Intel C++ 25 | 26 | #elif defined(__GNUC__) 27 | 28 | // GNU C++ 29 | 30 | # if defined(__MINGW32__) || defined(__CYGWIN__) 31 | # pragma pack (push, 8) 32 | # endif 33 | 34 | # if defined(__OBJC__) 35 | # if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1) 36 | # if !defined(STDNET_DISABLE_OBJC_WORKAROUND) 37 | # if !defined(Protocol) && !defined(id) 38 | # define Protocol cpp_Protocol 39 | # define id cpp_id 40 | # define STDNET_OBJC_WORKAROUND 41 | # endif 42 | # endif 43 | # endif 44 | # endif 45 | 46 | #elif defined(__KCC) 47 | 48 | // Kai C++ 49 | 50 | #elif defined(__sgi) 51 | 52 | // SGI MIPSpro C++ 53 | 54 | #elif defined(__DECCXX) 55 | 56 | // Compaq Tru64 Unix cxx 57 | 58 | #elif defined(__ghs) 59 | 60 | // Greenhills C++ 61 | 62 | #elif defined(__BORLANDC__) 63 | 64 | // Borland C++ 65 | 66 | # pragma option push -a8 -b -Ve- -Vx- -w-inl -vi- 67 | # pragma nopushoptwarn 68 | # pragma nopackwarning 69 | # if !defined(__MT__) 70 | # error Multithreaded RTL must be selected. 71 | # endif // !defined(__MT__) 72 | 73 | #elif defined(__MWERKS__) 74 | 75 | // Metrowerks CodeWarrior 76 | 77 | #elif defined(__SUNPRO_CC) 78 | 79 | // Sun Workshop Compiler C++ 80 | 81 | #elif defined(__HP_aCC) 82 | 83 | // HP aCC 84 | 85 | #elif defined(__MRC__) || defined(__SC__) 86 | 87 | // MPW MrCpp or SCpp 88 | 89 | #elif defined(__IBMCPP__) 90 | 91 | // IBM Visual Age 92 | 93 | #elif defined(_MSC_VER) 94 | 95 | // Microsoft Visual C++ 96 | // 97 | // Must remain the last #elif since some other vendors (Metrowerks, for example) 98 | // also #define _MSC_VER 99 | 100 | # pragma warning (disable:4103) 101 | # pragma warning (push) 102 | # pragma warning (disable:4127) 103 | # pragma warning (disable:4180) 104 | # pragma warning (disable:4244) 105 | # pragma warning (disable:4355) 106 | # pragma warning (disable:4512) 107 | # pragma warning (disable:4675) 108 | # if defined(_M_IX86) && defined(_Wp64) 109 | // The /Wp64 option is broken. If you want to check 64 bit portability, use a 110 | // 64 bit compiler! 111 | # pragma warning (disable:4311) 112 | # pragma warning (disable:4312) 113 | # endif // defined(_M_IX86) && defined(_Wp64) 114 | # pragma pack (push, 8) 115 | // Note that if the /Og optimisation flag is enabled with MSVC6, the compiler 116 | // has a tendency to incorrectly optimise away some calls to member template 117 | // functions, even though those functions contain code that should not be 118 | // optimised away! Therefore we will always disable this optimisation option 119 | // for the MSVC6 compiler. 120 | # if (_MSC_VER < 1300) 121 | # pragma optimize ("g", off) 122 | # endif 123 | # if !defined(_MT) 124 | # error Multithreaded RTL must be selected. 125 | # endif // !defined(_MT) 126 | 127 | #endif 128 | -------------------------------------------------------------------------------- /include/std/net/detail/socket_ops.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/socket_ops.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_SOCKET_OPS_HPP 12 | #define STDNET_DETAIL_SOCKET_OPS_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | 20 | #include 21 | #include "std/net/detail/socket_types.hpp" 22 | 23 | #include "std/net/detail/push_options.hpp" 24 | 25 | namespace std { 26 | namespace experimental { 27 | namespace net { 28 | namespace detail { 29 | namespace socket_ops { 30 | 31 | STDNET_DECL const char* inet_ntop(int af, const void* src, char* dest, 32 | size_t length, unsigned long scope_id, std::error_code& ec); 33 | 34 | STDNET_DECL int inet_pton(int af, const char* src, void* dest, 35 | unsigned long* scope_id, std::error_code& ec); 36 | 37 | STDNET_DECL u_long_type network_to_host_long(u_long_type value); 38 | 39 | STDNET_DECL u_long_type host_to_network_long(u_long_type value); 40 | 41 | STDNET_DECL u_short_type network_to_host_short(u_short_type value); 42 | 43 | STDNET_DECL u_short_type host_to_network_short(u_short_type value); 44 | 45 | } // namespace socket_ops 46 | } // namespace detail 47 | } // namespace net 48 | } // namespace experimental 49 | } // namespace std 50 | 51 | #include "std/net/detail/pop_options.hpp" 52 | 53 | #if defined(STDNET_HEADER_ONLY) 54 | # include "std/net/detail/impl/socket_ops.ipp" 55 | #endif // defined(STDNET_HEADER_ONLY) 56 | 57 | #endif // STDNET_DETAIL_SOCKET_OPS_HPP 58 | -------------------------------------------------------------------------------- /include/std/net/detail/socket_types.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/socket_types.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_SOCKET_TYPES_HPP 12 | #define STDNET_DETAIL_SOCKET_TYPES_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | 20 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 21 | # if defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_) 22 | # error WinSock.h has already been included 23 | # endif // defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_) 24 | # if defined(__BORLANDC__) 25 | # include // Needed for __errno 26 | # if !defined(_WSPIAPI_H_) 27 | # define _WSPIAPI_H_ 28 | # define STDNET_WSPIAPI_H_DEFINED 29 | # endif // !defined(_WSPIAPI_H_) 30 | # endif // defined(__BORLANDC__) 31 | # include 32 | # include 33 | # include 34 | # if defined(STDNET_WSPIAPI_H_DEFINED) 35 | # undef _WSPIAPI_H_ 36 | # undef STDNET_WSPIAPI_H_DEFINED 37 | # endif // defined(STDNET_WSPIAPI_H_DEFINED) 38 | # if !defined(STDNET_NO_DEFAULT_LINKED_LIBS) 39 | # if defined(UNDER_CE) 40 | # pragma comment(lib, "ws2.lib") 41 | # elif defined(_MSC_VER) || defined(__BORLANDC__) 42 | # pragma comment(lib, "ws2_32.lib") 43 | # pragma comment(lib, "mswsock.lib") 44 | # endif // defined(_MSC_VER) || defined(__BORLANDC__) 45 | # endif // !defined(STDNET_NO_DEFAULT_LINKED_LIBS) 46 | # include "std/net/detail/old_win_sdk_compat.hpp" 47 | #else 48 | # include 49 | # if !defined(__SYMBIAN32__) 50 | # include 51 | # endif 52 | # include 53 | # include 54 | # include 55 | # if defined(__hpux) 56 | # include 57 | # endif 58 | # if !defined(__hpux) || defined(__SELECT) 59 | # include 60 | # endif 61 | # include 62 | # include 63 | # include 64 | # include 65 | # if !defined(__SYMBIAN32__) 66 | # include 67 | # endif 68 | # include 69 | # include 70 | # include 71 | # include 72 | # if defined(__sun) 73 | # include 74 | # include 75 | # endif 76 | #endif 77 | 78 | #include "std/net/detail/push_options.hpp" 79 | 80 | namespace std { 81 | namespace experimental { 82 | namespace net { 83 | namespace detail { 84 | 85 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 86 | typedef SOCKET socket_type; 87 | const SOCKET invalid_socket = INVALID_SOCKET; 88 | const int socket_error_retval = SOCKET_ERROR; 89 | const int max_addr_v4_str_len = 256; 90 | const int max_addr_v6_str_len = 256; 91 | typedef sockaddr socket_addr_type; 92 | typedef in_addr in4_addr_type; 93 | typedef ip_mreq in4_mreq_type; 94 | typedef sockaddr_in sockaddr_in4_type; 95 | # if defined(STDNET_HAS_OLD_WIN_SDK) 96 | typedef in6_addr_emulation in6_addr_type; 97 | typedef ipv6_mreq_emulation in6_mreq_type; 98 | typedef sockaddr_in6_emulation sockaddr_in6_type; 99 | typedef sockaddr_storage_emulation sockaddr_storage_type; 100 | typedef addrinfo_emulation addrinfo_type; 101 | # else 102 | typedef in6_addr in6_addr_type; 103 | typedef ipv6_mreq in6_mreq_type; 104 | typedef sockaddr_in6 sockaddr_in6_type; 105 | typedef sockaddr_storage sockaddr_storage_type; 106 | typedef addrinfo addrinfo_type; 107 | # endif 108 | typedef unsigned long ioctl_arg_type; 109 | typedef u_long u_long_type; 110 | typedef u_short u_short_type; 111 | typedef int signed_size_type; 112 | const int shutdown_receive = SD_RECEIVE; 113 | const int shutdown_send = SD_SEND; 114 | const int shutdown_both = SD_BOTH; 115 | const int message_peek = MSG_PEEK; 116 | const int message_out_of_band = MSG_OOB; 117 | const int message_do_not_route = MSG_DONTROUTE; 118 | const int message_end_of_record = 0; // Not supported on Windows. 119 | # if defined (_WIN32_WINNT) 120 | const int max_iov_len = 64; 121 | # else 122 | const int max_iov_len = 16; 123 | # endif 124 | #else 125 | typedef int socket_type; 126 | const int invalid_socket = -1; 127 | const int socket_error_retval = -1; 128 | const int max_addr_v4_str_len = INET_ADDRSTRLEN; 129 | #if defined(INET6_ADDRSTRLEN) 130 | const int max_addr_v6_str_len = INET6_ADDRSTRLEN + 1 + IF_NAMESIZE; 131 | #else // defined(INET6_ADDRSTRLEN) 132 | const int max_addr_v6_str_len = 256; 133 | #endif // defined(INET6_ADDRSTRLEN) 134 | typedef sockaddr socket_addr_type; 135 | typedef in_addr in4_addr_type; 136 | # if defined(__hpux) 137 | // HP-UX doesn't provide ip_mreq when _XOPEN_SOURCE_EXTENDED is defined. 138 | struct in4_mreq_type 139 | { 140 | struct in_addr imr_multiaddr; 141 | struct in_addr imr_interface; 142 | }; 143 | # else 144 | typedef ip_mreq in4_mreq_type; 145 | # endif 146 | typedef sockaddr_in sockaddr_in4_type; 147 | typedef in6_addr in6_addr_type; 148 | typedef ipv6_mreq in6_mreq_type; 149 | typedef sockaddr_in6 sockaddr_in6_type; 150 | typedef sockaddr_storage sockaddr_storage_type; 151 | typedef sockaddr_un sockaddr_un_type; 152 | typedef addrinfo addrinfo_type; 153 | typedef int ioctl_arg_type; 154 | typedef uint32_t u_long_type; 155 | typedef uint16_t u_short_type; 156 | #if defined(STDNET_HAS_SSIZE_T) 157 | typedef ssize_t signed_size_type; 158 | #else // defined(STDNET_HAS_SSIZE_T) 159 | typedef int signed_size_type; 160 | #endif // defined(STDNET_HAS_SSIZE_T) 161 | const int shutdown_receive = SHUT_RD; 162 | const int shutdown_send = SHUT_WR; 163 | const int shutdown_both = SHUT_RDWR; 164 | const int message_peek = MSG_PEEK; 165 | const int message_out_of_band = MSG_OOB; 166 | const int message_do_not_route = MSG_DONTROUTE; 167 | const int message_end_of_record = MSG_EOR; 168 | # if defined(IOV_MAX) 169 | const int max_iov_len = IOV_MAX; 170 | # else 171 | // POSIX platforms are not required to define IOV_MAX. 172 | const int max_iov_len = 16; 173 | # endif 174 | #endif 175 | const int custom_socket_option_level = 0xA5100000; 176 | const int enable_connection_aborted_option = 1; 177 | const int always_fail_option = 2; 178 | 179 | } // namespace detail 180 | } // namespace net 181 | } // namespace experimental 182 | } // namespace std 183 | 184 | #include "std/net/detail/pop_options.hpp" 185 | 186 | #endif // STDNET_DETAIL_SOCKET_TYPES_HPP 187 | -------------------------------------------------------------------------------- /include/std/net/detail/system_errors.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // system_errors.hpp 3 | // ~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_SYSTEM_ERRORS_HPP 12 | #define STDNET_DETAIL_SYSTEM_ERRORS_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 21 | # include 22 | #else 23 | # include 24 | #endif 25 | 26 | #if defined(GENERATING_DOCUMENTATION) 27 | /// INTERNAL ONLY. 28 | # define STDNET_NATIVE_ERROR(e) implementation_defined 29 | /// INTERNAL ONLY. 30 | # define STDNET_SOCKET_ERROR(e) implementation_defined 31 | /// INTERNAL ONLY. 32 | # define STDNET_NETDB_ERROR(e) implementation_defined 33 | /// INTERNAL ONLY. 34 | # define STDNET_GETADDRINFO_ERROR(e) implementation_defined 35 | /// INTERNAL ONLY. 36 | # define STDNET_WIN_OR_POSIX(e_win, e_posix) implementation_defined 37 | #elif defined(STDNET_WINDOWS) || defined(__CYGWIN__) 38 | # define STDNET_NATIVE_ERROR(e) e 39 | # define STDNET_SOCKET_ERROR(e) WSA ## e 40 | # define STDNET_NETDB_ERROR(e) WSA ## e 41 | # define STDNET_GETADDRINFO_ERROR(e) WSA ## e 42 | # define STDNET_WIN_OR_POSIX(e_win, e_posix) e_win 43 | #else 44 | # define STDNET_NATIVE_ERROR(e) e 45 | # define STDNET_SOCKET_ERROR(e) e 46 | # define STDNET_NETDB_ERROR(e) e 47 | # define STDNET_GETADDRINFO_ERROR(e) e 48 | # define STDNET_WIN_OR_POSIX(e_win, e_posix) e_posix 49 | #endif 50 | 51 | #include "std/net/detail/push_options.hpp" 52 | 53 | namespace std { 54 | namespace experimental { 55 | namespace net { 56 | namespace detail { 57 | namespace syserrc { 58 | 59 | enum system_errors 60 | { 61 | /// Permission denied. 62 | access_denied = STDNET_SOCKET_ERROR(EACCES), 63 | 64 | /// Address family not supported by protocol. 65 | address_family_not_supported = STDNET_SOCKET_ERROR(EAFNOSUPPORT), 66 | 67 | /// Address already in use. 68 | address_in_use = STDNET_SOCKET_ERROR(EADDRINUSE), 69 | 70 | /// Transport endpoint is already connected. 71 | already_connected = STDNET_SOCKET_ERROR(EISCONN), 72 | 73 | /// Operation already in progress. 74 | already_started = STDNET_SOCKET_ERROR(EALREADY), 75 | 76 | /// Broken pipe. 77 | broken_pipe = STDNET_WIN_OR_POSIX( 78 | STDNET_NATIVE_ERROR(ERROR_BROKEN_PIPE), 79 | STDNET_NATIVE_ERROR(EPIPE)), 80 | 81 | /// A connection has been aborted. 82 | connection_aborted = STDNET_SOCKET_ERROR(ECONNABORTED), 83 | 84 | /// Connection refused. 85 | connection_refused = STDNET_SOCKET_ERROR(ECONNREFUSED), 86 | 87 | /// Connection reset by peer. 88 | connection_reset = STDNET_SOCKET_ERROR(ECONNRESET), 89 | 90 | /// Bad file descriptor. 91 | bad_descriptor = STDNET_SOCKET_ERROR(EBADF), 92 | 93 | /// Bad address. 94 | fault = STDNET_SOCKET_ERROR(EFAULT), 95 | 96 | /// No route to host. 97 | host_unreachable = STDNET_SOCKET_ERROR(EHOSTUNREACH), 98 | 99 | /// Operation now in progress. 100 | in_progress = STDNET_SOCKET_ERROR(EINPROGRESS), 101 | 102 | /// Interrupted system call. 103 | interrupted = STDNET_SOCKET_ERROR(EINTR), 104 | 105 | /// Invalid argument. 106 | invalid_argument = STDNET_SOCKET_ERROR(EINVAL), 107 | 108 | /// Message too long. 109 | message_size = STDNET_SOCKET_ERROR(EMSGSIZE), 110 | 111 | /// The name was too long. 112 | name_too_long = STDNET_SOCKET_ERROR(ENAMETOOLONG), 113 | 114 | /// Network is down. 115 | network_down = STDNET_SOCKET_ERROR(ENETDOWN), 116 | 117 | /// Network dropped connection on reset. 118 | network_reset = STDNET_SOCKET_ERROR(ENETRESET), 119 | 120 | /// Network is unreachable. 121 | network_unreachable = STDNET_SOCKET_ERROR(ENETUNREACH), 122 | 123 | /// Too many open files. 124 | no_descriptors = STDNET_SOCKET_ERROR(EMFILE), 125 | 126 | /// No buffer space available. 127 | no_buffer_space = STDNET_SOCKET_ERROR(ENOBUFS), 128 | 129 | /// Cannot allocate memory. 130 | no_memory = STDNET_WIN_OR_POSIX( 131 | STDNET_NATIVE_ERROR(ERROR_OUTOFMEMORY), 132 | STDNET_NATIVE_ERROR(ENOMEM)), 133 | 134 | /// Operation not permitted. 135 | no_permission = STDNET_WIN_OR_POSIX( 136 | STDNET_NATIVE_ERROR(ERROR_ACCESS_DENIED), 137 | STDNET_NATIVE_ERROR(EPERM)), 138 | 139 | /// Protocol not available. 140 | no_protocol_option = STDNET_SOCKET_ERROR(ENOPROTOOPT), 141 | 142 | /// Transport endpoint is not connected. 143 | not_connected = STDNET_SOCKET_ERROR(ENOTCONN), 144 | 145 | /// Socket operation on non-socket. 146 | not_socket = STDNET_SOCKET_ERROR(ENOTSOCK), 147 | 148 | /// Operation cancelled. 149 | operation_aborted = STDNET_WIN_OR_POSIX( 150 | STDNET_NATIVE_ERROR(ERROR_OPERATION_ABORTED), 151 | STDNET_NATIVE_ERROR(ECANCELED)), 152 | 153 | /// Operation not supported. 154 | operation_not_supported = STDNET_SOCKET_ERROR(EOPNOTSUPP), 155 | 156 | /// Cannot send after transport endpoint shutdown. 157 | shut_down = STDNET_SOCKET_ERROR(ESHUTDOWN), 158 | 159 | /// Connection timed out. 160 | timed_out = STDNET_SOCKET_ERROR(ETIMEDOUT), 161 | 162 | /// Resource temporarily unavailable. 163 | try_again = STDNET_WIN_OR_POSIX( 164 | STDNET_NATIVE_ERROR(ERROR_RETRY), 165 | STDNET_NATIVE_ERROR(EAGAIN)), 166 | 167 | /// The socket is marked non-blocking and the requested operation would block. 168 | would_block = STDNET_SOCKET_ERROR(EWOULDBLOCK) 169 | }; 170 | 171 | } // namespace syserrc 172 | 173 | /// Returns the error category used for the system errors. 174 | extern STDNET_DECL const std::error_category& system_category(); 175 | 176 | } // namespace detail 177 | } // namespace net 178 | } // namespace experimental 179 | } // namespace std 180 | 181 | namespace std { 182 | 183 | template<> struct is_error_code_enum< 184 | std::experimental::net::detail::syserrc::system_errors> 185 | { 186 | static const bool value = true; 187 | }; 188 | 189 | } // namespace std 190 | 191 | namespace std { 192 | namespace experimental { 193 | namespace net { 194 | namespace detail { 195 | namespace syserrc { 196 | 197 | inline std::error_code make_error_code(system_errors e) 198 | { 199 | return std::error_code(static_cast(e), 200 | std::experimental::net::detail::system_category()); 201 | } 202 | 203 | } // namespace syserrc 204 | } // namespace detail 205 | } // namespace net 206 | } // namespace experimental 207 | } // namespace std 208 | 209 | #include "std/net/detail/pop_options.hpp" 210 | 211 | #undef STDNET_NATIVE_ERROR 212 | #undef STDNET_SOCKET_ERROR 213 | #undef STDNET_NETDB_ERROR 214 | #undef STDNET_GETADDRINFO_ERROR 215 | #undef STDNET_WIN_OR_POSIX 216 | 217 | #if defined(STDNET_HEADER_ONLY) 218 | # include "std/net/detail/impl/system_errors.ipp" 219 | #endif // defined(STDNET_HEADER_ONLY) 220 | 221 | #endif // STDNET_DETAIL_SYSTEM_ERRORS_HPP 222 | -------------------------------------------------------------------------------- /include/std/net/detail/throw_error.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/throw_error.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_THROW_ERROR_HPP 12 | #define STDNET_DETAIL_THROW_ERROR_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | 21 | #include "std/net/detail/push_options.hpp" 22 | 23 | namespace std { 24 | namespace experimental { 25 | namespace net { 26 | namespace detail { 27 | 28 | STDNET_DECL void do_throw_error(const std::error_code& err); 29 | 30 | STDNET_DECL void do_throw_error(const std::error_code& err, 31 | const char* location); 32 | 33 | inline void throw_error(const std::error_code& err) 34 | { 35 | if (err) 36 | do_throw_error(err); 37 | } 38 | 39 | inline void throw_error(const std::error_code& err, 40 | const char* location) 41 | { 42 | if (err) 43 | do_throw_error(err, location); 44 | } 45 | 46 | } // namespace detail 47 | } // namespace net 48 | } // namespace experimental 49 | } // namespace std 50 | 51 | #include "std/net/detail/pop_options.hpp" 52 | 53 | #if defined(STDNET_HEADER_ONLY) 54 | # include "std/net/detail/impl/throw_error.ipp" 55 | #endif // defined(STDNET_HEADER_ONLY) 56 | 57 | #endif // STDNET_DETAIL_THROW_ERROR_HPP 58 | -------------------------------------------------------------------------------- /include/std/net/detail/throw_exception.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/throw_exception.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_THROW_EXCEPTION_HPP 12 | #define STDNET_DETAIL_THROW_EXCEPTION_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | 20 | namespace std { 21 | namespace experimental { 22 | namespace net { 23 | namespace detail { 24 | 25 | // Declare the throw_exception function for all targets. 26 | template 27 | void throw_exception(const Exception& e); 28 | 29 | // Only define the throw_exception function when exceptions are enabled. 30 | // Otherwise, it is up to the application to provide a definition of this 31 | // function. 32 | # if !defined(STDNET_NO_EXCEPTIONS) 33 | template 34 | void throw_exception(const Exception& e) 35 | { 36 | throw e; 37 | } 38 | # endif // !defined(STDNET_NO_EXCEPTIONS) 39 | 40 | } // namespace detail 41 | } // namespace net 42 | } // namespace experimental 43 | } // namespace std 44 | 45 | #endif // STDNET_DETAIL_THROW_EXCEPTION_HPP 46 | -------------------------------------------------------------------------------- /include/std/net/detail/winsock_init.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // detail/winsock_init.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_DETAIL_WINSOCK_INIT_HPP 12 | #define STDNET_DETAIL_WINSOCK_INIT_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | 20 | #if defined(STDNET_WINDOWS) || defined(__CYGWIN__) 21 | 22 | #include "std/net/detail/push_options.hpp" 23 | 24 | namespace std { 25 | namespace experimental { 26 | namespace net { 27 | namespace detail { 28 | 29 | class winsock_init_base 30 | { 31 | protected: 32 | // Structure to track result of initialisation and number of uses. POD is used 33 | // to ensure that the values are zero-initialised prior to any code being run. 34 | struct data 35 | { 36 | long init_count_; 37 | long result_; 38 | }; 39 | 40 | STDNET_DECL static void startup(data& d, 41 | unsigned char major, unsigned char minor); 42 | 43 | STDNET_DECL static void cleanup(data& d); 44 | 45 | STDNET_DECL static void throw_on_error(data& d); 46 | }; 47 | 48 | template 49 | class winsock_init : private winsock_init_base 50 | { 51 | public: 52 | winsock_init(bool allow_throw = true) 53 | { 54 | startup(data_, Major, Minor); 55 | if (allow_throw) 56 | throw_on_error(data_); 57 | } 58 | 59 | winsock_init(const winsock_init&) 60 | { 61 | startup(data_, Major, Minor); 62 | throw_on_error(data_); 63 | } 64 | 65 | ~winsock_init() 66 | { 67 | cleanup(data_); 68 | } 69 | 70 | private: 71 | static data data_; 72 | }; 73 | 74 | template 75 | winsock_init_base::data winsock_init::data_; 76 | 77 | // Static variable to ensure that winsock is initialised before main, and 78 | // therefore before any other threads can get started. 79 | static const winsock_init<>& winsock_init_instance = winsock_init<>(false); 80 | 81 | } // namespace detail 82 | } // namespace net 83 | } // namespace experimental 84 | } // namespace std 85 | 86 | #include "std/net/detail/pop_options.hpp" 87 | 88 | #if defined(STDNET_HEADER_ONLY) 89 | # include "std/net/detail/impl/winsock_init.ipp" 90 | #endif // defined(STDNET_HEADER_ONLY) 91 | 92 | #endif // defined(STDNET_WINDOWS) || defined(__CYGWIN__) 93 | 94 | #endif // STDNET_DETAIL_WINSOCK_INIT_HPP 95 | -------------------------------------------------------------------------------- /include/std/net/ip/address.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/address.hpp 3 | // ~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_ADDRESS_HPP 12 | #define STDNET_IP_ADDRESS_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include 21 | #include 22 | #include "std/net/ip/fwd.hpp" 23 | #include "std/net/ip/address_v4.hpp" 24 | #include "std/net/ip/address_v6.hpp" 25 | 26 | #if !defined(STDNET_NO_IOSTREAM) 27 | # include 28 | #endif // !defined(STDNET_NO_IOSTREAM) 29 | 30 | #include "std/net/detail/push_options.hpp" 31 | 32 | namespace std { 33 | namespace experimental { 34 | namespace net { 35 | namespace ip { 36 | namespace detail { 37 | 38 | template 39 | struct is_convertible_to_address_1 : false_type {}; 40 | 41 | template 42 | struct is_convertible_to_address_1(declval()))>::value>::type> : true_type {}; 45 | 46 | template 47 | struct is_convertible_to_address : is_convertible_to_address_1 {}; 48 | 49 | template <> 50 | struct is_convertible_to_address
: false_type {}; 51 | 52 | } // namespace detail 53 | 54 | //template <> struct is_convertible_to_address
: false_type {}; 55 | 56 | /// Implements version-independent IP addresses. 57 | /** 58 | * The ip::address class provides the ability to use either IP version 4 or 59 | * version 6 addresses. 60 | * 61 | * @par Thread Safety 62 | * @e Distinct @e objects: Safe.@n 63 | * @e Shared @e objects: Unsafe. 64 | */ 65 | class address 66 | { 67 | public: 68 | /// Default constructor. 69 | STDNET_CONSTEXPR address() STDNET_NOEXCEPT 70 | : type_(invalid), 71 | ipv4_address_(), 72 | ipv6_address_() 73 | { 74 | } 75 | 76 | /// Construct from another address type. 77 | template ::value>::type> 80 | STDNET_CONSTEXPR address(const T& t) STDNET_NOEXCEPT; 81 | 82 | #if defined(STDNET_HAS_VARIADIC_TEMPLATES) 83 | /// Explicitly construct from a list of arguments. 84 | template ()...))>::value>::type> 87 | explicit STDNET_CONSTEXPR address(T&&... t); 88 | #else // defined(STDNET_HAS_VARIADIC_TEMPLATES) 89 | template 90 | explicit address(T1& t1, typename enable_if()))>::value>::type* = 0) 92 | { *this = make_address(t1); } 93 | template 94 | explicit address(const T1& t1, typename enable_if()))>::value>::type* = 0) 96 | { *this = make_address(t1); } 97 | template 98 | address(T1& t1, T2& t2, typename enable_if(), declval()))>::value>::type* = 0) 100 | { *this = make_address(t1, t2); } 101 | template 102 | address(T1& t1, const T2& t2, typename enable_if(), declval()))>::value>::type* = 0) 104 | { *this = make_address(t1, t2); } 105 | template 106 | address(const T1& t1, T2& t2, typename enable_if(), declval()))>::value>::type* = 0) 108 | { *this = make_address(t1, t2); } 109 | template 110 | address(const T1& t1, const T2& t2, typename enable_if(), declval()))>::value>::type* = 0) 112 | { *this = make_address(t1, t2); } 113 | #endif // defined(STDNET_HAS_VARIADIC_TEMPLATES) 114 | 115 | /// Copy constructor. 116 | STDNET_CONSTEXPR address(const address& other) STDNET_NOEXCEPT 117 | : type_(other.type_), 118 | ipv4_address_(other.ipv4_address_), 119 | ipv6_address_(other.ipv6_address_) 120 | { 121 | } 122 | 123 | #if defined(STDNET_HAS_MOVE) 124 | /// Move constructor. 125 | address(address&& other) STDNET_NOEXCEPT 126 | : type_(other.type_), 127 | ipv4_address_(other.ipv4_address_), 128 | ipv6_address_(other.ipv6_address_) 129 | { 130 | } 131 | #endif // defined(STDNET_HAS_MOVE) 132 | 133 | /// Assign from another address. 134 | address& operator=(const address& other) STDNET_NOEXCEPT 135 | { 136 | type_ = other.type_; 137 | ipv4_address_ = other.ipv4_address_; 138 | ipv6_address_ = other.ipv6_address_; 139 | return *this; 140 | } 141 | 142 | #if defined(STDNET_HAS_MOVE) 143 | /// Move-assign from another address. 144 | address& operator=(address&& other) STDNET_NOEXCEPT 145 | { 146 | type_ = other.type_; 147 | ipv4_address_ = other.ipv4_address_; 148 | ipv6_address_ = other.ipv6_address_; 149 | return *this; 150 | } 151 | #endif // defined(STDNET_HAS_MOVE) 152 | 153 | /// Get whether the address is an IP version 4 address. 154 | STDNET_CONSTEXPR bool is_v4() const STDNET_NOEXCEPT 155 | { 156 | return type_ == ipv4; 157 | } 158 | 159 | /// Get whether the address is an IP version 6 address. 160 | STDNET_CONSTEXPR bool is_v6() const STDNET_NOEXCEPT 161 | { 162 | return type_ == ipv6; 163 | } 164 | 165 | /// Get the address as a string in dotted decimal format. 166 | STDNET_DECL std::string to_string() const; 167 | 168 | /// Get the address as a string in dotted decimal format. 169 | STDNET_DECL std::string to_string(std::error_code& ec) const; 170 | 171 | /// Determine whether the address is a loopback address. 172 | STDNET_CONSTEXPR bool is_loopback() const STDNET_NOEXCEPT 173 | { 174 | return (type_ == ipv4) ? ipv4_address_.is_loopback() : 175 | (type_ == ipv6) ? ipv6_address_.is_loopback() : false; 176 | } 177 | 178 | /// Determine whether the address is unspecified. 179 | STDNET_CONSTEXPR bool is_unspecified() const STDNET_NOEXCEPT 180 | { 181 | return (type_ == ipv4) ? ipv4_address_.is_unspecified() : 182 | (type_ == ipv6) ? ipv6_address_.is_unspecified() : false; 183 | } 184 | 185 | /// Determine whether the address is a multicast address. 186 | STDNET_CONSTEXPR bool is_multicast() const STDNET_NOEXCEPT 187 | { 188 | return (type_ == ipv4) ? ipv4_address_.is_multicast() : 189 | (type_ == ipv6) ? ipv6_address_.is_multicast() : false; 190 | } 191 | 192 | /// Compare two addresses for equality. 193 | friend bool operator==(const address& a1, 194 | const address& a2) STDNET_NOEXCEPT 195 | { 196 | if (a1.type_ != a2.type_) 197 | return false; 198 | if (a1.type_ == address::ipv4) 199 | return a1.ipv4_address_ == a2.ipv4_address_; 200 | if (a1.type_ == address::ipv6) 201 | return a1.ipv4_address_ == a2.ipv4_address_; 202 | return true; 203 | } 204 | 205 | /// Compare two addresses for inequality. 206 | friend bool operator!=(const address& a1, const address& a2) STDNET_NOEXCEPT 207 | { 208 | return !(a1 == a2); 209 | } 210 | 211 | /// Compare addresses for ordering. 212 | friend bool operator<(const address& a1, 213 | const address& a2) STDNET_NOEXCEPT 214 | { 215 | if (a1.type_ < a2.type_) 216 | return true; 217 | if (a1.type_ > a2.type_) 218 | return false; 219 | if (a1.type_ == address::ipv4) 220 | return a1.ipv4_address_ < a2.ipv4_address_; 221 | if (a1.type_ == address::ipv6) 222 | return a1.ipv6_address_ < a2.ipv6_address_; 223 | return false; 224 | } 225 | 226 | /// Compare addresses for ordering. 227 | friend bool operator>(const address& a1, const address& a2) STDNET_NOEXCEPT 228 | { 229 | return a2 < a1; 230 | } 231 | 232 | /// Compare addresses for ordering. 233 | friend bool operator<=(const address& a1, const address& a2) STDNET_NOEXCEPT 234 | { 235 | return !(a2 < a1); 236 | } 237 | 238 | /// Compare addresses for ordering. 239 | friend bool operator>=(const address& a1, const address& a2) STDNET_NOEXCEPT 240 | { 241 | return !(a1 < a2); 242 | } 243 | 244 | private: 245 | friend class address_v4; 246 | friend class address_v6; 247 | 248 | // The type of the address. 249 | enum address_type { invalid, ipv4, ipv6 } type_; 250 | 251 | // The underlying IPv4 address. 252 | address_v4 ipv4_address_; 253 | 254 | // The underlying IPv6 address. 255 | address_v6 ipv6_address_; 256 | 257 | // Helper constructor for address_cast. 258 | STDNET_CONSTEXPR address(address_type type, 259 | const address_v4& v4, const address_v6& v6) 260 | : type_(type), 261 | ipv4_address_(v4), 262 | ipv6_address_(v6) 263 | { 264 | } 265 | 266 | template friend STDNET_CONSTEXPR T address_cast(const address&, 267 | typename enable_if::value>::type*); 268 | template friend STDNET_CONSTEXPR T address_cast(const address&, 269 | typename enable_if::value>::type*); 270 | template friend STDNET_CONSTEXPR T address_cast(const address_v4&, 271 | typename enable_if::value>::type*) STDNET_NOEXCEPT; 272 | template friend STDNET_CONSTEXPR T address_cast(const address_v6&, 273 | typename enable_if::value>::type*) STDNET_NOEXCEPT; 274 | }; 275 | 276 | /// Create an address from an IPv4 address string in dotted decimal form, 277 | /// or from an IPv6 address in hexadecimal notation. 278 | STDNET_DECL address make_address(const char* str); 279 | 280 | /// Create an address from an IPv4 address string in dotted decimal form, 281 | /// or from an IPv6 address in hexadecimal notation. 282 | STDNET_DECL address make_address(const char* str, 283 | std::error_code& ec) STDNET_NOEXCEPT; 284 | 285 | /// Create an address from an IPv4 address string in dotted decimal form, 286 | /// or from an IPv6 address in hexadecimal notation. 287 | STDNET_DECL address make_address(const std::string& str); 288 | 289 | /// Create an address from an IPv4 address string in dotted decimal form, 290 | /// or from an IPv6 address in hexadecimal notation. 291 | STDNET_DECL address make_address(const std::string& str, 292 | std::error_code& ec) STDNET_NOEXCEPT; 293 | 294 | #if !defined(STDNET_NO_IOSTREAM) 295 | 296 | /// Output an address as a string. 297 | /** 298 | * Used to output a human-readable string for a specified address. 299 | * 300 | * @param os The output stream to which the string will be written. 301 | * 302 | * @param addr The address to be written. 303 | * 304 | * @return The output stream. 305 | * 306 | * @relates std::experimental::net::ip::address 307 | */ 308 | template 309 | std::basic_ostream& operator<<( 310 | std::basic_ostream& os, const address& addr); 311 | 312 | #endif // !defined(STDNET_NO_IOSTREAM) 313 | 314 | } // namespace ip 315 | } // namespace net 316 | } // namespace experimental 317 | } // namespace std 318 | 319 | #include "std/net/detail/pop_options.hpp" 320 | 321 | #include "std/net/ip/impl/address.hpp" 322 | #if defined(STDNET_HEADER_ONLY) 323 | # include "std/net/ip/impl/address.ipp" 324 | #endif // defined(STDNET_HEADER_ONLY) 325 | 326 | #include "std/net/ip/address_cast.hpp" 327 | 328 | #endif // STDNET_IP_ADDRESS_HPP 329 | -------------------------------------------------------------------------------- /include/std/net/ip/address_cast.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/address_cast.hpp 3 | // ~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_ADDRESS_CAST_HPP 12 | #define STDNET_IP_ADDRESS_CAST_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include "std/net/detail/throw_exception.hpp" 20 | #include "std/net/ip/fwd.hpp" 21 | #include "std/net/ip/address.hpp" 22 | #include "std/net/ip/address_v4.hpp" 23 | #include "std/net/ip/address_v6.hpp" 24 | #include "std/net/ip/bad_address_cast.hpp" 25 | 26 | #include "std/net/detail/push_options.hpp" 27 | 28 | namespace std { 29 | namespace experimental { 30 | namespace net { 31 | namespace ip { 32 | 33 | /// Cast a version-independent address to itself. 34 | template 35 | inline STDNET_CONSTEXPR T address_cast(const address& addr, 36 | typename enable_if::value>::type*) STDNET_NOEXCEPT 37 | { 38 | return addr; 39 | } 40 | 41 | /// Cast a version-independent address to an IPv4 address. 42 | /** 43 | * @throws bad_address_cast if @c a does not represent an IPv4 address. 44 | */ 45 | template 46 | inline STDNET_CONSTEXPR T address_cast(const address& addr, 47 | typename enable_if::value>::type*) 48 | { 49 | return (addr.type_ != address::ipv4) 50 | ? throw bad_address_cast() 51 | : addr.ipv4_address_; 52 | } 53 | 54 | /// Cast a version-independent address to an IPv6 address. 55 | /** 56 | * @throws bad_address_cast if @c a does not represent an IPv6 address. 57 | */ 58 | template 59 | inline STDNET_CONSTEXPR T address_cast(const address& addr, 60 | typename enable_if::value>::type*) 61 | { 62 | return (addr.type_ != address::ipv6) 63 | ? throw bad_address_cast() 64 | : addr.ipv6_address_; 65 | } 66 | 67 | /// Cast an IPv4 address to a version-independent address. 68 | template 69 | inline STDNET_CONSTEXPR T address_cast(const address_v4& addr, 70 | typename enable_if::value>::type*) STDNET_NOEXCEPT 71 | { 72 | return address(address::ipv4, addr, address_v6()); 73 | } 74 | 75 | /// Cast an IPv4 address to itself. 76 | template 77 | inline STDNET_CONSTEXPR T address_cast(const address_v4& addr, 78 | typename enable_if::value>::type*) STDNET_NOEXCEPT 79 | { 80 | return addr; 81 | } 82 | 83 | /// Cast an IPv6 address to a version-independent address. 84 | template 85 | inline STDNET_CONSTEXPR T address_cast(const address_v6& addr, 86 | typename enable_if::value>::type*) STDNET_NOEXCEPT 87 | { 88 | return address(address::ipv6, address_v4(), addr); 89 | } 90 | 91 | /// Cast an IPv6 address to itself. 92 | template 93 | inline STDNET_CONSTEXPR T address_cast(const address_v6& addr, 94 | typename enable_if::value>::type*) STDNET_NOEXCEPT 95 | { 96 | return addr; 97 | } 98 | 99 | } // namespace ip 100 | } // namespace net 101 | } // namespace experimental 102 | } // namespace std 103 | 104 | #include "std/net/detail/pop_options.hpp" 105 | 106 | #endif // STDNET_IP_ADDRESS_CAST_HPP 107 | -------------------------------------------------------------------------------- /include/std/net/ip/address_v4.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/address_v4.hpp 3 | // ~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_ADDRESS_V4_HPP 12 | #define STDNET_IP_ADDRESS_V4_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include 21 | #include 22 | #include "std/net/ip/fwd.hpp" 23 | #include "std/net/detail/winsock_init.hpp" 24 | 25 | #if !defined(STDNET_NO_IOSTREAM) 26 | # include 27 | #endif // !defined(STDNET_NO_IOSTREAM) 28 | 29 | #include "std/net/detail/push_options.hpp" 30 | 31 | namespace std { 32 | namespace experimental { 33 | namespace net { 34 | namespace ip { 35 | 36 | class address; 37 | 38 | /// Implements IP version 4 style addresses. 39 | /** 40 | * The ip::address_v4 class provides the ability to use and manipulate IP 41 | * version 4 addresses. 42 | * 43 | * @par Thread Safety 44 | * @e Distinct @e objects: Safe.@n 45 | * @e Shared @e objects: Unsafe. 46 | */ 47 | class address_v4 48 | { 49 | public: 50 | /// A standard-layout type used to represent an address as an array of bytes. 51 | struct bytes_type : std::array 52 | { 53 | #if defined(STDNET_HAS_VARIADIC_TEMPLATES) 54 | template 55 | explicit STDNET_CONSTEXPR bytes_type(T... t) 56 | : std::array{{static_cast(t)...}} 57 | { 58 | } 59 | #else // defined(STDNET_HAS_VARIADIC_TEMPLATES) 60 | explicit STDNET_CONSTEXPR bytes_type(unsigned char a = 0, 61 | unsigned char b = 0, unsigned char c = 0, unsigned char d = 0) 62 | # if defined(STDNET_HAS_CONSTEXPR) 63 | : std::array{{a, b, c, d}} 64 | { 65 | } 66 | # else // defined(STDNET_HAS_CONSTEXPR) 67 | { 68 | (*this)[0] = a, (*this)[1] = b, (*this)[2] = c, (*this)[3] = d; 69 | } 70 | # endif // defined(STDNET_HAS_CONSTEXPR) 71 | #endif // defined(STDNET_HAS_VARIADIC_TEMPLATES) 72 | }; 73 | 74 | /// Default constructor. 75 | STDNET_CONSTEXPR address_v4() STDNET_NOEXCEPT 76 | : bytes_(0, 0, 0, 0) 77 | { 78 | } 79 | 80 | /// Implicit construction from bytes, in network byte order. 81 | STDNET_CONSTEXPR address_v4(const bytes_type& bytes) 82 | : bytes_( 83 | #if UCHAR_MAX > 0xFF 84 | (bytes[0] > 0xFF || bytes[1] > 0xFF || bytes[2] > 0xFF || bytes[3] > 0xFF) 85 | ? throw std::out_of_range("address_v4 from bytes_type") : 86 | #endif // UCHAR_MAX > 0xFF 87 | bytes) 88 | { 89 | } 90 | 91 | #if defined(STDNET_HAS_VARIADIC_TEMPLATES) 92 | /// Explicitly construct from a list of arguments. 93 | template ()...))>::value>::type> 96 | explicit STDNET_CONSTEXPR address_v4(T&&... t) 97 | : address_v4(make_address_v4(static_cast(t)...)) 98 | { 99 | } 100 | #else // defined(STDNET_HAS_VARIADIC_TEMPLATES) 101 | template 102 | explicit STDNET_CONSTEXPR address_v4(T1& t1, 103 | typename enable_if()))>::value>::type* = 0) 105 | : bytes_(make_address_v4(t1).to_bytes()) {} 106 | template 107 | explicit STDNET_CONSTEXPR address_v4(const T1& t1, 108 | typename enable_if()))>::value>::type* = 0) 110 | : bytes_(make_address_v4(t1).to_bytes()) {} 111 | template 112 | STDNET_CONSTEXPR address_v4(T1& t1, T2& t2, 113 | typename enable_if(), declval()))>::value>::type* = 0) 115 | : bytes_(make_address_v4(t1, t2).to_bytes()) {} 116 | template 117 | STDNET_CONSTEXPR address_v4(T1& t1, const T2& t2, 118 | typename enable_if(), declval()))>::value>::type* = 0) 120 | : bytes_(make_address_v4(t1, t2).to_bytes()) {} 121 | template 122 | STDNET_CONSTEXPR address_v4(const T1& t1, T2& t2, 123 | typename enable_if(), declval()))>::value>::type* = 0) 125 | : bytes_(make_address_v4(t1, t2).to_bytes()) {} 126 | template 127 | STDNET_CONSTEXPR address_v4(const T1& t1, const T2& t2, 128 | typename enable_if(), declval()))>::value>::type* = 0) 130 | : bytes_(make_address_v4(t1, t2).to_bytes()) {} 131 | #endif // defined(STDNET_HAS_VARIADIC_TEMPLATES) 132 | 133 | /// Copy constructor. 134 | STDNET_CONSTEXPR address_v4(const address_v4& other) STDNET_NOEXCEPT 135 | : bytes_(other.bytes_) 136 | { 137 | } 138 | 139 | #if defined(STDNET_HAS_MOVE) 140 | /// Move constructor. 141 | address_v4(address_v4&& other) STDNET_NOEXCEPT 142 | : bytes_(other.bytes_) 143 | { 144 | } 145 | #endif // defined(STDNET_HAS_MOVE) 146 | 147 | /// Assign from another address. 148 | address_v4& operator=(const address_v4& other) STDNET_NOEXCEPT 149 | { 150 | bytes_ = other.bytes_; 151 | return *this; 152 | } 153 | 154 | #if defined(STDNET_HAS_MOVE) 155 | /// Move-assign from another address. 156 | address_v4& operator=(address_v4&& other) STDNET_NOEXCEPT 157 | { 158 | bytes_ = other.bytes_; 159 | return *this; 160 | } 161 | #endif // defined(STDNET_HAS_MOVE) 162 | 163 | /// Get the address in bytes, in network byte order. 164 | STDNET_CONSTEXPR bytes_type to_bytes() const STDNET_NOEXCEPT 165 | { 166 | return bytes_; 167 | } 168 | 169 | /// Get the address as an unsigned long in host byte order 170 | STDNET_CONSTEXPR unsigned long to_ulong() const STDNET_NOEXCEPT 171 | { 172 | return (static_cast(bytes_[0]) << 24) 173 | | (static_cast(bytes_[1]) << 16) 174 | | (static_cast(bytes_[2]) << 8) 175 | | static_cast(bytes_[3]); 176 | } 177 | 178 | /// Get the address as a string in dotted decimal format. 179 | STDNET_DECL std::string to_string() const; 180 | 181 | /// Get the address as a string in dotted decimal format. 182 | STDNET_DECL std::string to_string(std::error_code& ec) const; 183 | 184 | /// Determine whether the address is a loopback address. 185 | STDNET_CONSTEXPR bool is_loopback() const STDNET_NOEXCEPT 186 | { 187 | return (to_ulong() & 0xFF000000) == 0x7F000000; 188 | } 189 | 190 | /// Determine whether the address is unspecified. 191 | STDNET_CONSTEXPR bool is_unspecified() const STDNET_NOEXCEPT 192 | { 193 | return to_ulong() == 0; 194 | } 195 | 196 | /// Determine whether the address is a class A address. 197 | STDNET_CONSTEXPR bool is_class_a() const STDNET_NOEXCEPT 198 | { 199 | return (to_ulong() & 0x80000000) == 0; 200 | } 201 | 202 | /// Determine whether the address is a class B address. 203 | STDNET_CONSTEXPR bool is_class_b() const STDNET_NOEXCEPT 204 | { 205 | return (to_ulong() & 0xC0000000) == 0x80000000; 206 | } 207 | 208 | /// Determine whether the address is a class C address. 209 | STDNET_CONSTEXPR bool is_class_c() const STDNET_NOEXCEPT 210 | { 211 | return (to_ulong() & 0xE0000000) == 0xC0000000; 212 | } 213 | 214 | /// Determine whether the address is a multicast address. 215 | STDNET_CONSTEXPR bool is_multicast() const STDNET_NOEXCEPT 216 | { 217 | return (to_ulong() & 0xF0000000) == 0xE0000000; 218 | } 219 | 220 | /// Compare two addresses for equality. 221 | friend bool operator==(const address_v4& a1, 222 | const address_v4& a2) STDNET_NOEXCEPT 223 | { 224 | return a1.bytes_ == a2.bytes_; 225 | } 226 | 227 | /// Compare two addresses for inequality. 228 | friend bool operator!=(const address_v4& a1, 229 | const address_v4& a2) STDNET_NOEXCEPT 230 | { 231 | return a1.bytes_ == a2.bytes_; 232 | } 233 | 234 | /// Compare addresses for ordering. 235 | friend bool operator<(const address_v4& a1, 236 | const address_v4& a2) STDNET_NOEXCEPT 237 | { 238 | return a1.to_ulong() < a2.to_ulong(); 239 | } 240 | 241 | /// Compare addresses for ordering. 242 | friend bool operator>(const address_v4& a1, 243 | const address_v4& a2) STDNET_NOEXCEPT 244 | { 245 | return a1.to_ulong() > a2.to_ulong(); 246 | } 247 | 248 | /// Compare addresses for ordering. 249 | friend bool operator<=(const address_v4& a1, 250 | const address_v4& a2) STDNET_NOEXCEPT 251 | { 252 | return a1.to_ulong() <= a2.to_ulong(); 253 | } 254 | 255 | /// Compare addresses for ordering. 256 | friend bool operator>=(const address_v4& a1, 257 | const address_v4& a2) STDNET_NOEXCEPT 258 | { 259 | return a1.to_ulong() >= a2.to_ulong(); 260 | } 261 | 262 | /// Obtain an address object that represents any address. 263 | static STDNET_CONSTEXPR address_v4 any() STDNET_NOEXCEPT 264 | { 265 | return address_v4(); 266 | } 267 | 268 | /// Obtain an address object that represents the loopback address. 269 | static STDNET_CONSTEXPR address_v4 loopback() STDNET_NOEXCEPT 270 | { 271 | return address_v4(0x7F000001); 272 | } 273 | 274 | /// Obtain an address object that represents the broadcast address. 275 | static STDNET_CONSTEXPR address_v4 broadcast() STDNET_NOEXCEPT 276 | { 277 | return address_v4(0xFFFFFFFF); 278 | } 279 | 280 | /// Obtain an address object that represents the broadcast address that 281 | /// corresponds to the specified address and netmask. 282 | static STDNET_CONSTEXPR address_v4 broadcast(const address_v4& addr, 283 | const address_v4& mask) STDNET_NOEXCEPT 284 | { 285 | return address_v4(addr.to_ulong() | (mask.to_ulong() ^ 0xFFFFFFFF)); 286 | } 287 | 288 | private: 289 | // The underlying IPv4 address. 290 | bytes_type bytes_; 291 | }; 292 | 293 | /// Construct an address_v4 from raw bytes. 294 | inline STDNET_CONSTEXPR address_v4 make_address_v4(const address_v4::bytes_type& bytes) 295 | { 296 | return bytes; 297 | } 298 | 299 | /// Construct an address_v4 from a unsigned long in host byte order. 300 | inline STDNET_CONSTEXPR address_v4 make_address_v4(unsigned long addr) 301 | { 302 | return 303 | #if ULONG_MAX > 0xFFFFFFFF 304 | (addr > 0xFFFFFFFF) 305 | ? throw std::out_of_range("address_v4 from unsigned long") : 306 | #endif // ULONG_MAX > 0xFFFFFFFF 307 | address_v4::bytes_type((addr >> 24) & 0xFF, 308 | (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF); 309 | } 310 | 311 | /// Create an address_v4 from an IPv4 address string in dotted decimal form. 312 | STDNET_DECL address_v4 make_address_v4(const char* str); 313 | 314 | /// Create an address_v4 from an IPv4 address string in dotted decimal form. 315 | STDNET_DECL address_v4 make_address_v4(const char* str, 316 | std::error_code& ec) STDNET_NOEXCEPT; 317 | 318 | /// Create an address_v4 from an IPv4 address string in dotted decimal form. 319 | STDNET_DECL address_v4 make_address_v4(const std::string& str); 320 | 321 | /// Create an address_v4 from an IPv4 address string in dotted decimal form. 322 | STDNET_DECL address_v4 make_address_v4(const std::string& str, 323 | std::error_code& ec) STDNET_NOEXCEPT; 324 | 325 | #if defined(STDNET_HAS_CONSTEXPR) 326 | 327 | /// The IPv4 unspecified address. 328 | STDNET_CONSTEXPR address_v4 any_v4(0); 329 | 330 | /// The IPv4 loopback address. 331 | STDNET_CONSTEXPR address_v4 loopback_v4(0x7F000001); 332 | 333 | /// The IPv4 broadcast address. 334 | STDNET_CONSTEXPR address_v4 broadcast_v4(0xFFFFFFFF); 335 | 336 | #else // defined(STDNET_HAS_CONSTEXPR) 337 | 338 | static const address_v4 any_v4(0); 339 | static const address_v4 loopback_v4(0x7F000001); 340 | static const address_v4 broadcast_v4(0xFFFFFFFF); 341 | 342 | #endif // defined(STDNET_HAS_CONSTEXPR) 343 | 344 | #if !defined(STDNET_NO_IOSTREAM) 345 | 346 | /// Output an address as a string. 347 | /** 348 | * Used to output a human-readable string for a specified address. 349 | * 350 | * @param os The output stream to which the string will be written. 351 | * 352 | * @param addr The address to be written. 353 | * 354 | * @return The output stream. 355 | * 356 | * @relates std::experimental::net::ip::address_v4 357 | */ 358 | template 359 | std::basic_ostream& operator<<( 360 | std::basic_ostream& os, const address_v4& addr); 361 | 362 | #endif // !defined(STDNET_NO_IOSTREAM) 363 | 364 | } // namespace ip 365 | } // namespace net 366 | } // namespace experimental 367 | } // namespace std 368 | 369 | #include "std/net/detail/pop_options.hpp" 370 | 371 | #include "std/net/ip/impl/address_v4.hpp" 372 | #if defined(STDNET_HEADER_ONLY) 373 | # include "std/net/ip/impl/address_v4.ipp" 374 | #endif // defined(STDNET_HEADER_ONLY) 375 | 376 | #endif // STDNET_IP_ADDRESS_V4_HPP 377 | -------------------------------------------------------------------------------- /include/std/net/ip/address_v6.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/address_v6.hpp 3 | // ~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_ADDRESS_V6_HPP 12 | #define STDNET_IP_ADDRESS_V6_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include 21 | #include 22 | #include "std/net/ip/fwd.hpp" 23 | #include "std/net/ip/address_v4.hpp" 24 | #include "std/net/ip/bad_address_cast.hpp" 25 | #include "std/net/detail/winsock_init.hpp" 26 | 27 | #if !defined(STDNET_NO_IOSTREAM) 28 | # include 29 | #endif // !defined(STDNET_NO_IOSTREAM) 30 | 31 | #include "std/net/detail/push_options.hpp" 32 | 33 | namespace std { 34 | namespace experimental { 35 | namespace net { 36 | namespace ip { 37 | 38 | class address; 39 | class address_v4; 40 | 41 | /// Implements IP version 6 style addresses. 42 | /** 43 | * The ip::address_v6 class provides the ability to use and manipulate IP 44 | * version 6 addresses. 45 | * 46 | * @par Thread Safety 47 | * @e Distinct @e objects: Safe.@n 48 | * @e Shared @e objects: Unsafe. 49 | */ 50 | class address_v6 51 | { 52 | public: 53 | /// A standard-layout type used to represent an address as an array of bytes. 54 | struct bytes_type : std::array 55 | { 56 | #if defined(STDNET_HAS_VARIADIC_TEMPLATES) 57 | template 58 | explicit STDNET_CONSTEXPR bytes_type(T... t) 59 | : std::array{{static_cast(t)...}} 60 | { 61 | } 62 | #else // defined(STDNET_HAS_VARIADIC_TEMPLATES) 63 | explicit STDNET_CONSTEXPR bytes_type( 64 | unsigned char a = 0, unsigned char b = 0, 65 | unsigned char c = 0, unsigned char d = 0, 66 | unsigned char e = 0, unsigned char f = 0, 67 | unsigned char g = 0, unsigned char h = 0, 68 | unsigned char i = 0, unsigned char j = 0, 69 | unsigned char k = 0, unsigned char l = 0, 70 | unsigned char m = 0, unsigned char n = 0, 71 | unsigned char o = 0, unsigned char p = 0) 72 | # if defined(STDNET_HAS_CONSTEXPR) 73 | : std::array{{a, b, c, d, e, f, g, h, i, h, k, l, m, n, o, p}} 74 | { 75 | } 76 | # else // defined(STDNET_HAS_CONSTEXPR) 77 | { 78 | (*this)[0] = a, (*this)[1] = b, (*this)[2] = c, (*this)[3] = d; 79 | (*this)[4] = e, (*this)[5] = f, (*this)[6] = g, (*this)[7] = h; 80 | (*this)[8] = i, (*this)[9] = j, (*this)[10] = k, (*this)[11] = l; 81 | (*this)[12] = m, (*this)[13] = n, (*this)[14] = o, (*this)[15] = p; 82 | } 83 | # endif // defined(STDNET_HAS_CONSTEXPR) 84 | #endif // defined(STDNET_HAS_VARIADIC_TEMPLATES) 85 | }; 86 | 87 | /// Default constructor. 88 | STDNET_CONSTEXPR address_v6() STDNET_NOEXCEPT 89 | : bytes_(0), 90 | scope_id_(0) 91 | { 92 | } 93 | 94 | /// Implicit construction from bytes, in network byte order. 95 | STDNET_CONSTEXPR address_v6(const bytes_type& bytes, unsigned long scope = 0) 96 | : bytes_( 97 | #if UCHAR_MAX > 0xFF 98 | (bytes[0] > 0xFF || bytes[1] > 0xFF || bytes[2] > 0xFF || bytes[3] > 0xFF 99 | || bytes[4] > 0xFF || bytes[5] > 0xFF || bytes[6] > 0xFF || bytes[7] > 0xFF 100 | || bytes[8] > 0xFF || bytes[9] > 0xFF || bytes[10] > 0xFF || bytes[11] > 0xFF 101 | || bytes[12] > 0xFF || bytes[13] > 0xFF || bytes[14] > 0xFF || bytes[15] > 0xFF) 102 | ? throw std::out_of_range("address_v6 from bytes_type") : 103 | #endif // UCHAR_MAX > 0xFF 104 | bytes), 105 | scope_id_(scope) 106 | { 107 | } 108 | 109 | #if defined(STDNET_HAS_VARIADIC_TEMPLATES) 110 | /// Explicitly construct from a list of arguments. 111 | template ()...))>::value>::type> 114 | explicit STDNET_CONSTEXPR address_v6(T&&... t) 115 | : address_v6(make_address_v6(static_cast(t)...)) 116 | { 117 | } 118 | #else // defined(STDNET_HAS_VARIADIC_TEMPLATES) 119 | template 120 | explicit STDNET_CONSTEXPR address_v6(T1& t1, 121 | typename enable_if()))>::value>::type* = 0) 123 | : bytes_(make_address_v6(t1).to_bytes()) {} 124 | template 125 | explicit STDNET_CONSTEXPR address_v6(const T1& t1, 126 | typename enable_if()))>::value>::type* = 0) 128 | : bytes_(make_address_v6(t1).to_bytes()) {} 129 | template 130 | STDNET_CONSTEXPR address_v6(T1& t1, T2& t2, 131 | typename enable_if(), declval()))>::value>::type* = 0) 133 | : bytes_(make_address_v6(t1, t2).to_bytes()) {} 134 | template 135 | STDNET_CONSTEXPR address_v6(T1& t1, const T2& t2, 136 | typename enable_if(), declval()))>::value>::type* = 0) 138 | : bytes_(make_address_v6(t1, t2).to_bytes()) {} 139 | template 140 | STDNET_CONSTEXPR address_v6(const T1& t1, T2& t2, 141 | typename enable_if(), declval()))>::value>::type* = 0) 143 | : bytes_(make_address_v6(t1, t2).to_bytes()) {} 144 | template 145 | STDNET_CONSTEXPR address_v6(const T1& t1, const T2& t2, 146 | typename enable_if(), declval()))>::value>::type* = 0) 148 | : bytes_(make_address_v6(t1, t2).to_bytes()) {} 149 | #endif // defined(STDNET_HAS_VARIADIC_TEMPLATES) 150 | 151 | /// Copy constructor. 152 | STDNET_CONSTEXPR address_v6(const address_v6& other) STDNET_NOEXCEPT 153 | : bytes_(other.bytes_), scope_id_(other.scope_id_) 154 | { 155 | } 156 | 157 | #if defined(STDNET_HAS_MOVE) 158 | /// Move constructor. 159 | address_v6(address_v6&& other) STDNET_NOEXCEPT 160 | : bytes_(other.bytes_), scope_id_(other.scope_id_) 161 | { 162 | } 163 | #endif // defined(STDNET_HAS_MOVE) 164 | 165 | /// Assign from another address. 166 | address_v6& operator=(const address_v6& other) STDNET_NOEXCEPT 167 | { 168 | bytes_ = other.bytes_; 169 | scope_id_ = other.scope_id_; 170 | return *this; 171 | } 172 | 173 | #if defined(STDNET_HAS_MOVE) 174 | /// Move-assign from another address. 175 | address_v6& operator=(address_v6&& other) STDNET_NOEXCEPT 176 | { 177 | bytes_ = other.bytes_; 178 | scope_id_ = other.scope_id_; 179 | return *this; 180 | } 181 | #endif // defined(STDNET_HAS_MOVE) 182 | 183 | /// The scope ID of the address. 184 | /** 185 | * Returns the scope ID associated with the IPv6 address. 186 | */ 187 | STDNET_CONSTEXPR unsigned long scope_id() const STDNET_NOEXCEPT 188 | { 189 | return scope_id_; 190 | } 191 | 192 | /// The scope ID of the address. 193 | /** 194 | * Modifies the scope ID associated with the IPv6 address. 195 | */ 196 | void scope_id(unsigned long id) STDNET_NOEXCEPT 197 | { 198 | scope_id_ = id; 199 | } 200 | 201 | /// Get the address in bytes, in network byte order. 202 | STDNET_CONSTEXPR bytes_type to_bytes() const STDNET_NOEXCEPT 203 | { 204 | return bytes_; 205 | } 206 | 207 | /// Get the address as a string. 208 | STDNET_DECL std::string to_string() const; 209 | 210 | /// Get the address as a string. 211 | STDNET_DECL std::string to_string(std::error_code& ec) const; 212 | 213 | /// Determine whether the address is a loopback address. 214 | STDNET_CONSTEXPR bool is_loopback() const STDNET_NOEXCEPT 215 | { 216 | return ((bytes_[0] == 0) && (bytes_[1] == 0) 217 | && (bytes_[2] == 0) && (bytes_[3] == 0) 218 | && (bytes_[4] == 0) && (bytes_[5] == 0) 219 | && (bytes_[6] == 0) && (bytes_[7] == 0) 220 | && (bytes_[8] == 0) && (bytes_[9] == 0) 221 | && (bytes_[10] == 0) && (bytes_[11] == 0) 222 | && (bytes_[12] == 0) && (bytes_[13] == 0) 223 | && (bytes_[14] == 0) && (bytes_[15] == 1)); 224 | } 225 | 226 | /// Determine whether the address is unspecified. 227 | STDNET_CONSTEXPR bool is_unspecified() const STDNET_NOEXCEPT 228 | { 229 | return ((bytes_[0] == 0) && (bytes_[1] == 0) 230 | && (bytes_[2] == 0) && (bytes_[3] == 0) 231 | && (bytes_[4] == 0) && (bytes_[5] == 0) 232 | && (bytes_[6] == 0) && (bytes_[7] == 0) 233 | && (bytes_[8] == 0) && (bytes_[9] == 0) 234 | && (bytes_[10] == 0) && (bytes_[11] == 0) 235 | && (bytes_[12] == 0) && (bytes_[13] == 0) 236 | && (bytes_[14] == 0) && (bytes_[15] == 0)); 237 | } 238 | 239 | /// Determine whether the address is link local. 240 | STDNET_CONSTEXPR bool is_link_local() const STDNET_NOEXCEPT 241 | { 242 | return ((bytes_[0] == 0xfe) && ((bytes_[1] & 0xc0) == 0x80)); 243 | } 244 | 245 | /// Determine whether the address is site local. 246 | STDNET_CONSTEXPR bool is_site_local() const STDNET_NOEXCEPT 247 | { 248 | return ((bytes_[0] == 0xfe) && ((bytes_[1] & 0xc0) == 0xc0)); 249 | } 250 | 251 | /// Determine whether the address is a mapped IPv4 address. 252 | STDNET_CONSTEXPR bool is_v4_mapped() const STDNET_NOEXCEPT 253 | { 254 | return ((bytes_[0] == 0) && (bytes_[1] == 0) 255 | && (bytes_[2] == 0) && (bytes_[3] == 0) 256 | && (bytes_[4] == 0) && (bytes_[5] == 0) 257 | && (bytes_[6] == 0) && (bytes_[7] == 0) 258 | && (bytes_[8] == 0) && (bytes_[9] == 0) 259 | && (bytes_[10] == 0xff) && (bytes_[11] == 0xff)); 260 | } 261 | 262 | /// Determine whether the address is a multicast address. 263 | STDNET_CONSTEXPR bool is_multicast() const STDNET_NOEXCEPT 264 | { 265 | return (bytes_[0] == 0xff); 266 | } 267 | 268 | /// Determine whether the address is a global multicast address. 269 | STDNET_CONSTEXPR bool is_multicast_global() const STDNET_NOEXCEPT 270 | { 271 | return ((bytes_[0] == 0xff) && ((bytes_[1] & 0x0f) == 0x0e)); 272 | } 273 | 274 | /// Determine whether the address is a link-local multicast address. 275 | STDNET_CONSTEXPR bool is_multicast_link_local() const STDNET_NOEXCEPT 276 | { 277 | return ((bytes_[0] == 0xff) && ((bytes_[1] & 0x0f) == 0x02)); 278 | } 279 | 280 | /// Determine whether the address is a node-local multicast address. 281 | STDNET_CONSTEXPR bool is_multicast_node_local() const STDNET_NOEXCEPT 282 | { 283 | return ((bytes_[0] == 0xff) && ((bytes_[1] & 0x0f) == 0x01)); 284 | } 285 | 286 | /// Determine whether the address is a org-local multicast address. 287 | STDNET_CONSTEXPR bool is_multicast_org_local() const STDNET_NOEXCEPT 288 | { 289 | return ((bytes_[0] == 0xff) && ((bytes_[1] & 0x0f) == 0x08)); 290 | } 291 | 292 | /// Determine whether the address is a site-local multicast address. 293 | STDNET_CONSTEXPR bool is_multicast_site_local() const STDNET_NOEXCEPT 294 | { 295 | return ((bytes_[0] == 0xff) && ((bytes_[1] & 0x0f) == 0x05)); 296 | } 297 | 298 | /// Compare two addresses for equality. 299 | friend bool operator==(const address_v6& a1, 300 | const address_v6& a2) STDNET_NOEXCEPT 301 | { 302 | return a1.bytes_ == a2.bytes_ && a1.scope_id_ == a2.scope_id_; 303 | } 304 | 305 | /// Compare two addresses for inequality. 306 | friend bool operator!=(const address_v6& a1, 307 | const address_v6& a2) STDNET_NOEXCEPT 308 | { 309 | return !(a1 == a2); 310 | } 311 | 312 | /// Compare addresses for ordering. 313 | friend bool operator<(const address_v6& a1, 314 | const address_v6& a2) STDNET_NOEXCEPT 315 | { 316 | if (a1.bytes_ < a2.bytes_) 317 | return true; 318 | if (a1.bytes_ > a2.bytes_) 319 | return false; 320 | return a1.scope_id_ < a2.scope_id_; 321 | } 322 | 323 | /// Compare addresses for ordering. 324 | friend bool operator>(const address_v6& a1, 325 | const address_v6& a2) STDNET_NOEXCEPT 326 | { 327 | return a2 < a1; 328 | } 329 | 330 | /// Compare addresses for ordering. 331 | friend bool operator<=(const address_v6& a1, 332 | const address_v6& a2) STDNET_NOEXCEPT 333 | { 334 | return !(a2 < a1); 335 | } 336 | 337 | /// Compare addresses for ordering. 338 | friend bool operator>=(const address_v6& a1, 339 | const address_v6& a2) STDNET_NOEXCEPT 340 | { 341 | return !(a1 < a2); 342 | } 343 | 344 | /// Obtain an address object that represents any address. 345 | static STDNET_CONSTEXPR address_v6 any() STDNET_NOEXCEPT 346 | { 347 | return address_v6(); 348 | } 349 | 350 | /// Obtain an address object that represents the loopback address. 351 | static STDNET_CONSTEXPR address_v6 loopback() STDNET_NOEXCEPT 352 | { 353 | return bytes_type(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1); 354 | } 355 | 356 | private: 357 | friend STDNET_CONSTEXPR address_v4 make_address_v4( 358 | v4_mapped_t, const address_v6&); 359 | 360 | // The underlying IPv6 address. 361 | bytes_type bytes_; 362 | 363 | // The scope ID associated with the address. 364 | unsigned long scope_id_; 365 | }; 366 | 367 | /// Construct an address_v6 from raw bytes. 368 | inline STDNET_CONSTEXPR address_v6 make_address_v6( 369 | const address_v6::bytes_type& bytes, unsigned long scope_id = 0) 370 | { 371 | return address_v6(bytes, scope_id); 372 | } 373 | 374 | /// Create an address_v6 from an IPv6 address string. 375 | STDNET_DECL address_v6 make_address_v6(const char* str); 376 | 377 | /// Create an address_v6 from an IPv6 address string. 378 | STDNET_DECL address_v6 make_address_v6(const char* str, 379 | std::error_code& ec) STDNET_NOEXCEPT; 380 | 381 | /// Create an address_v6 from an IPv6 address string. 382 | STDNET_DECL address_v6 make_address_v6(const std::string& str); 383 | 384 | /// Create an address_v6 from an IPv6 address string. 385 | STDNET_DECL address_v6 make_address_v6(const std::string& str, 386 | std::error_code& ec) STDNET_NOEXCEPT; 387 | 388 | /// Create an IPv4-mapped address_v6 from an IPv4 address. 389 | inline STDNET_CONSTEXPR address_v6 make_address_v6( 390 | v4_mapped_t, const address_v4& addr) STDNET_NOEXCEPT 391 | { 392 | return address_v6::bytes_type(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 393 | static_cast(addr.to_bytes())[0], 394 | static_cast(addr.to_bytes())[1], 395 | static_cast(addr.to_bytes())[2], 396 | static_cast(addr.to_bytes())[3]); 397 | } 398 | 399 | /// Create an address_v4 from an IPv4-mapped address_v6. 400 | inline STDNET_CONSTEXPR address_v4 make_address_v4( 401 | v4_mapped_t, const address_v6& addr) 402 | { 403 | return !addr.is_v4_mapped() ? throw bad_address_cast() : 404 | address_v4::bytes_type(addr.bytes_[12], addr.bytes_[13], 405 | addr.bytes_[14], addr.bytes_[15]); 406 | } 407 | 408 | #if !defined(STDNET_NO_IOSTREAM) 409 | 410 | /// Output an address as a string. 411 | /** 412 | * Used to output a human-readable string for a specified address. 413 | * 414 | * @param os The output stream to which the string will be written. 415 | * 416 | * @param addr The address to be written. 417 | * 418 | * @return The output stream. 419 | * 420 | * @relates std::experimental::net::ip::address_v6 421 | */ 422 | template 423 | std::basic_ostream& operator<<( 424 | std::basic_ostream& os, const address_v6& addr); 425 | 426 | #endif // !defined(STDNET_NO_IOSTREAM) 427 | 428 | } // namespace ip 429 | } // namespace net 430 | } // namespace experimental 431 | } // namespace std 432 | 433 | #include "std/net/detail/pop_options.hpp" 434 | 435 | #include "std/net/ip/impl/address_v6.hpp" 436 | #if defined(STDNET_HEADER_ONLY) 437 | # include "std/net/ip/impl/address_v6.ipp" 438 | #endif // defined(STDNET_HEADER_ONLY) 439 | 440 | #endif // STDNET_IP_ADDRESS_V6_HPP 441 | -------------------------------------------------------------------------------- /include/std/net/ip/bad_address_cast.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/bad_address_cast.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_BAD_ADDRESS_CAST_HPP 12 | #define STDNET_IP_BAD_ADDRESS_CAST_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | 21 | #include "std/net/detail/push_options.hpp" 22 | 23 | namespace std { 24 | namespace experimental { 25 | namespace net { 26 | namespace ip { 27 | 28 | /// Exception thrown on a failed address_cast. 29 | class bad_address_cast 30 | : public bad_cast 31 | { 32 | public: 33 | virtual const char* what() const STDNET_NOEXCEPT 34 | { 35 | return "bad address cast"; 36 | } 37 | }; 38 | 39 | } // namespace ip 40 | } // namespace net 41 | } // namespace experimental 42 | } // namespace std 43 | 44 | #include "std/net/detail/pop_options.hpp" 45 | 46 | #endif // STDNET_IP_BAD_ADDRESS_CAST_HPP 47 | -------------------------------------------------------------------------------- /include/std/net/ip/fwd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/fwd.hpp 3 | // ~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_FWD_HPP 12 | #define STDNET_IP_FWD_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include 21 | #include 22 | #include 23 | 24 | #if !defined(STDNET_NO_IOSTREAM) 25 | # include 26 | #endif // !defined(STDNET_NO_IOSTREAM) 27 | 28 | #include "std/net/detail/push_options.hpp" 29 | 30 | namespace std { 31 | namespace experimental { 32 | namespace net { 33 | namespace ip { 34 | 35 | #if defined(STDNET_HAS_CONSTEXPR) 36 | struct v4_mapped_t { STDNET_CONSTEXPR v4_mapped_t() {} }; 37 | STDNET_CONSTEXPR v4_mapped_t v4_mapped; 38 | #else // !defined(STDNET_HAS_CONSTEXPR) 39 | enum v4_mapped_t { v4_mapped }; 40 | #endif // !defined(STDNET_HAS_CONSTEXPR) 41 | 42 | class address; 43 | class address_v4; 44 | class address_v6; 45 | 46 | // address comparisons: 47 | bool operator==(const address&, const address&) STDNET_NOEXCEPT; 48 | bool operator!=(const address&, const address&) STDNET_NOEXCEPT; 49 | bool operator< (const address&, const address&) STDNET_NOEXCEPT; 50 | bool operator> (const address&, const address&) STDNET_NOEXCEPT; 51 | bool operator<=(const address&, const address&) STDNET_NOEXCEPT; 52 | bool operator>=(const address&, const address&) STDNET_NOEXCEPT; 53 | 54 | // address creation: 55 | address make_address(const char*); 56 | address make_address(const char*, std::error_code&) STDNET_NOEXCEPT; 57 | address make_address(const std::string&); 58 | address make_address(const std::string&, std::error_code&) STDNET_NOEXCEPT; 59 | 60 | #if !defined(STDNET_NO_IOSTREAM) 61 | 62 | // address I/O: 63 | template 64 | basic_ostream& operator<<( 65 | basic_ostream&, const address&); 66 | 67 | #endif // !defined(STDNET_NO_IOSTREAM) 68 | 69 | // address_v4 comparisons: 70 | bool operator==(const address_v4&, const address_v4&) STDNET_NOEXCEPT; 71 | bool operator!=(const address_v4&, const address_v4&) STDNET_NOEXCEPT; 72 | bool operator< (const address_v4&, const address_v4&) STDNET_NOEXCEPT; 73 | bool operator> (const address_v4&, const address_v4&) STDNET_NOEXCEPT; 74 | bool operator<=(const address_v4&, const address_v4&) STDNET_NOEXCEPT; 75 | bool operator>=(const address_v4&, const address_v4&) STDNET_NOEXCEPT; 76 | 77 | // address_v4 creation: 78 | //STDNET_CONSTEXPR address_v4 make_address_v4(const address_v4::octets&); 79 | STDNET_CONSTEXPR address_v4 make_address_v4(unsigned long); 80 | STDNET_CONSTEXPR address_v4 make_address_v4(v4_mapped_t, const address_v6&); 81 | address_v4 make_address_v4(const char*); 82 | address_v4 make_address_v4(const char*, error_code&) STDNET_NOEXCEPT; 83 | address_v4 make_address_v4(const std::string&); 84 | address_v4 make_address_v4(const std::string&, std::error_code&) STDNET_NOEXCEPT; 85 | 86 | #if !defined(STDNET_NO_IOSTREAM) 87 | 88 | // address_v4 I/O: 89 | template 90 | basic_ostream& operator<<( 91 | basic_ostream&, const address_v4&); 92 | 93 | #endif // !defined(STDNET_NO_IOSTREAM) 94 | 95 | // address_v6 comparisons: 96 | bool operator==(const address_v6&, const address_v6&) STDNET_NOEXCEPT; 97 | bool operator!=(const address_v6&, const address_v6&) STDNET_NOEXCEPT; 98 | bool operator< (const address_v6&, const address_v6&) STDNET_NOEXCEPT; 99 | bool operator> (const address_v6&, const address_v6&) STDNET_NOEXCEPT; 100 | bool operator<=(const address_v6&, const address_v6&) STDNET_NOEXCEPT; 101 | bool operator>=(const address_v6&, const address_v6&) STDNET_NOEXCEPT; 102 | 103 | // address_v6 creation: 104 | //STDNET_CONSTEXPR address_v6 make_address_v6(const address_v6::octets&, unsigned long = 0); 105 | STDNET_CONSTEXPR address_v6 make_address_v6(v4_mapped_t, const address_v4&) STDNET_NOEXCEPT; 106 | address_v6 make_address_v6(const char*); 107 | address_v6 make_address_v6(const char*, error_code&) STDNET_NOEXCEPT; 108 | address_v6 make_address_v6(const std::string&); 109 | address_v6 make_address_v6(const std::string&, error_code&) STDNET_NOEXCEPT; 110 | 111 | #if !defined(STDNET_NO_IOSTREAM) 112 | 113 | // address_v6 I/O: 114 | template 115 | basic_ostream& operator<<( 116 | basic_ostream&, const address_v6&); 117 | 118 | #endif // !defined(STDNET_NO_IOSTREAM) 119 | 120 | class bad_address_cast; 121 | 122 | // address conversion: 123 | template STDNET_CONSTEXPR T address_cast(const address&, 124 | typename enable_if::value>::type* = 0) STDNET_NOEXCEPT; 125 | template STDNET_CONSTEXPR T address_cast(const address&, 126 | typename enable_if::value>::type* = 0); 127 | template STDNET_CONSTEXPR T address_cast(const address&, 128 | typename enable_if::value>::type* = 0); 129 | template STDNET_CONSTEXPR T address_cast(const address_v4&, 130 | typename enable_if::value>::type* = 0) STDNET_NOEXCEPT; 131 | template STDNET_CONSTEXPR T address_cast(const address_v4&, 132 | typename enable_if::value>::type* = 0) STDNET_NOEXCEPT; 133 | template T address_cast(const address_v4&, 134 | typename enable_if::value>::type* = 0) STDNET_DELETED; 135 | template STDNET_CONSTEXPR T address_cast(const address_v6&, 136 | typename enable_if::value>::type* = 0) STDNET_NOEXCEPT; 137 | template T address_cast(const address_v6&, 138 | typename enable_if::value>::type* = 0) STDNET_DELETED; 139 | template STDNET_CONSTEXPR T address_cast(const address_v6&, 140 | typename enable_if::value>::type* = 0) STDNET_NOEXCEPT; 141 | 142 | } // namespace ip 143 | } // namespace net 144 | } // namespace experimental 145 | } // namespace std 146 | 147 | #include "std/net/detail/pop_options.hpp" 148 | 149 | #endif // STDNET_IP_FWD_HPP 150 | -------------------------------------------------------------------------------- /include/std/net/ip/impl/address.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/impl/address.hpp 3 | // ~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_IMPL_ADDRESS_HPP 12 | #define STDNET_IP_IMPL_ADDRESS_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/throw_error.hpp" 19 | #include "std/net/ip/address_cast.hpp" 20 | 21 | #include "std/net/detail/push_options.hpp" 22 | 23 | namespace std { 24 | namespace experimental { 25 | namespace net { 26 | namespace ip { 27 | 28 | template 29 | inline STDNET_CONSTEXPR address::address(const T& t) STDNET_NOEXCEPT 30 | : address(address_cast
(t)) 31 | { 32 | } 33 | 34 | #if defined(STDNET_HAS_VARIADIC_TEMPLATES) 35 | 36 | template 37 | inline STDNET_CONSTEXPR address::address(T&&... t) 38 | : address(make_address(static_cast(t)...)) 39 | { 40 | } 41 | 42 | #endif // defined(STDNET_HAS_VARIADIC_TEMPLATES) 43 | 44 | #if !defined(STDNET_NO_IOSTREAM) 45 | 46 | template 47 | std::basic_ostream& operator<<( 48 | std::basic_ostream& os, const address& addr) 49 | { 50 | std::error_code ec; 51 | std::string s = addr.to_string(ec); 52 | if (ec) 53 | { 54 | if (os.exceptions() & std::basic_ostream::failbit) 55 | std::experimental::net::detail::throw_error(ec); 56 | else 57 | os.setstate(std::basic_ostream::failbit); 58 | } 59 | else 60 | for (std::string::iterator i = s.begin(); i != s.end(); ++i) 61 | os << os.widen(*i); 62 | return os; 63 | } 64 | 65 | #endif // !defined(STDNET_NO_IOSTREAM) 66 | 67 | } // namespace ip 68 | } // namespace net 69 | } // namespace experimental 70 | } // namespace std 71 | 72 | #include "std/net/detail/pop_options.hpp" 73 | 74 | #endif // STDNET_IP_IMPL_ADDRESS_HPP 75 | -------------------------------------------------------------------------------- /include/std/net/ip/impl/address.ipp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/impl/address.ipp 3 | // ~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_IMPL_ADDRESS_IPP 12 | #define STDNET_IP_IMPL_ADDRESS_IPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include 21 | #include "std/net/detail/throw_error.hpp" 22 | #include "std/net/detail/throw_exception.hpp" 23 | #include "std/net/detail/system_errors.hpp" 24 | #include "std/net/ip/address.hpp" 25 | 26 | #include "std/net/detail/push_options.hpp" 27 | 28 | namespace std { 29 | namespace experimental { 30 | namespace net { 31 | namespace ip { 32 | 33 | std::string address::to_string() const 34 | { 35 | if (type_ == ipv4) 36 | return ipv4_address_.to_string(); 37 | if (type_ == ipv6) 38 | return ipv6_address_.to_string(); 39 | throw bad_address_cast(); 40 | } 41 | 42 | std::string address::to_string(std::error_code& ec) const 43 | { 44 | if (type_ == ipv4) 45 | return ipv4_address_.to_string(ec); 46 | if (type_ == ipv6) 47 | return ipv6_address_.to_string(ec); 48 | throw bad_address_cast(); 49 | } 50 | 51 | address make_address(const char* str) 52 | { 53 | std::error_code ec; 54 | address addr = make_address(str, ec); 55 | std::experimental::net::detail::throw_error(ec); 56 | return addr; 57 | } 58 | 59 | address make_address(const char* str, 60 | std::error_code& ec) STDNET_NOEXCEPT 61 | { 62 | address_v6 ipv6_address = make_address_v6(str, ec); 63 | if (!ec) 64 | return ipv6_address; 65 | 66 | address_v4 ipv4_address = make_address_v4(str, ec); 67 | if (!ec) 68 | return ipv4_address; 69 | 70 | return address(); 71 | } 72 | 73 | address make_address(const std::string& str) 74 | { 75 | return make_address(str.c_str()); 76 | } 77 | 78 | address make_address(const std::string& str, 79 | std::error_code& ec) STDNET_NOEXCEPT 80 | { 81 | return make_address(str.c_str(), ec); 82 | } 83 | 84 | } // namespace ip 85 | } // namespace net 86 | } // namespace experimental 87 | } // namespace std 88 | 89 | #include "std/net/detail/pop_options.hpp" 90 | 91 | #endif // STDNET_IP_IMPL_ADDRESS_IPP 92 | -------------------------------------------------------------------------------- /include/std/net/ip/impl/address_v4.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/impl/address_v4.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_IMPL_ADDRESS_V4_HPP 12 | #define STDNET_IP_IMPL_ADDRESS_V4_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #if !defined(STDNET_NO_IOSTREAM) 19 | 20 | #include "std/net/detail/throw_error.hpp" 21 | 22 | #include "std/net/detail/push_options.hpp" 23 | 24 | namespace std { 25 | namespace experimental { 26 | namespace net { 27 | namespace ip { 28 | 29 | template 30 | std::basic_ostream& operator<<( 31 | std::basic_ostream& os, const address_v4& addr) 32 | { 33 | std::error_code ec; 34 | std::string s = addr.to_string(ec); 35 | if (ec) 36 | { 37 | if (os.exceptions() & std::basic_ostream::failbit) 38 | std::experimental::net::detail::throw_error(ec); 39 | else 40 | os.setstate(std::basic_ostream::failbit); 41 | } 42 | else 43 | for (std::string::iterator i = s.begin(); i != s.end(); ++i) 44 | os << os.widen(*i); 45 | return os; 46 | } 47 | 48 | } // namespace ip 49 | } // namespace net 50 | } // namespace experimental 51 | } // namespace std 52 | 53 | #include "std/net/detail/pop_options.hpp" 54 | 55 | #endif // !defined(STDNET_NO_IOSTREAM) 56 | 57 | #endif // STDNET_IP_IMPL_ADDRESS_V4_HPP 58 | -------------------------------------------------------------------------------- /include/std/net/ip/impl/address_v4.ipp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/impl/address_v4.ipp 3 | // ~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_IMPL_ADDRESS_V4_IPP 12 | #define STDNET_IP_IMPL_ADDRESS_V4_IPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include 20 | #include 21 | #include "std/net/detail/socket_ops.hpp" 22 | #include "std/net/detail/system_errors.hpp" 23 | #include "std/net/detail/throw_error.hpp" 24 | #include "std/net/detail/throw_exception.hpp" 25 | #include "std/net/ip/address_v4.hpp" 26 | 27 | #include "std/net/detail/push_options.hpp" 28 | 29 | namespace std { 30 | namespace experimental { 31 | namespace net { 32 | namespace ip { 33 | 34 | std::string address_v4::to_string() const 35 | { 36 | std::error_code ec; 37 | std::string addr = to_string(ec); 38 | std::experimental::net::detail::throw_error(ec); 39 | return addr; 40 | } 41 | 42 | std::string address_v4::to_string(std::error_code& ec) const 43 | { 44 | char addr_str[std::experimental::net::detail::max_addr_v4_str_len]; 45 | const char* addr = 46 | std::experimental::net::detail::socket_ops::inet_ntop( 47 | AF_INET, bytes_.data(), addr_str, 48 | std::experimental::net::detail::max_addr_v4_str_len, 0, ec); 49 | if (addr == 0) 50 | return std::string(); 51 | return addr; 52 | } 53 | 54 | address_v4 make_address_v4(const char* str) 55 | { 56 | std::error_code ec; 57 | address_v4 addr = make_address_v4(str, ec); 58 | std::experimental::net::detail::throw_error(ec); 59 | return addr; 60 | } 61 | 62 | address_v4 make_address_v4(const char* str, 63 | std::error_code& ec) STDNET_NOEXCEPT 64 | { 65 | address_v4::bytes_type bytes; 66 | if (std::experimental::net::detail::socket_ops::inet_pton( 67 | AF_INET, str, bytes.data(), 0, ec) <= 0) 68 | return address_v4(); 69 | return address_v4(bytes); 70 | } 71 | 72 | address_v4 make_address_v4(const std::string& str) 73 | { 74 | return make_address_v4(str.c_str()); 75 | } 76 | 77 | address_v4 make_address_v4(const std::string& str, 78 | std::error_code& ec) STDNET_NOEXCEPT 79 | { 80 | return make_address_v4(str.c_str(), ec); 81 | } 82 | 83 | } // namespace ip 84 | } // namespace net 85 | } // namespace experimental 86 | } // namespace std 87 | 88 | #include "std/net/detail/pop_options.hpp" 89 | 90 | #endif // STDNET_IP_IMPL_ADDRESS_V4_IPP 91 | -------------------------------------------------------------------------------- /include/std/net/ip/impl/address_v6.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/impl/address_v6.hpp 3 | // ~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_IMPL_ADDRESS_V6_HPP 12 | #define STDNET_IP_IMPL_ADDRESS_V6_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #if !defined(STDNET_NO_IOSTREAM) 19 | 20 | #include "std/net/detail/throw_error.hpp" 21 | 22 | #include "std/net/detail/push_options.hpp" 23 | 24 | namespace std { 25 | namespace experimental { 26 | namespace net { 27 | namespace ip { 28 | 29 | template 30 | std::basic_ostream& operator<<( 31 | std::basic_ostream& os, const address_v6& addr) 32 | { 33 | std::error_code ec; 34 | std::string s = addr.to_string(ec); 35 | if (ec) 36 | { 37 | if (os.exceptions() & std::basic_ostream::failbit) 38 | std::experimental::net::detail::throw_error(ec); 39 | else 40 | os.setstate(std::basic_ostream::failbit); 41 | } 42 | else 43 | for (std::string::iterator i = s.begin(); i != s.end(); ++i) 44 | os << os.widen(*i); 45 | return os; 46 | } 47 | 48 | } // namespace ip 49 | } // namespace net 50 | } // namespace experimental 51 | } // namespace std 52 | 53 | #include "std/net/detail/pop_options.hpp" 54 | 55 | #endif // !defined(STDNET_NO_IOSTREAM) 56 | 57 | #endif // STDNET_IP_IMPL_ADDRESS_V6_HPP 58 | -------------------------------------------------------------------------------- /include/std/net/ip/impl/address_v6.ipp: -------------------------------------------------------------------------------- 1 | // 2 | // ip/impl/address_v6.ipp 3 | // ~~~~~~~~~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_IP_IMPL_ADDRESS_V6_IPP 12 | #define STDNET_IP_IMPL_ADDRESS_V6_IPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/detail/config.hpp" 19 | #include "std/net/detail/socket_ops.hpp" 20 | #include "std/net/detail/system_errors.hpp" 21 | #include "std/net/detail/throw_error.hpp" 22 | #include "std/net/detail/throw_exception.hpp" 23 | #include "std/net/ip/address_v6.hpp" 24 | 25 | #include "std/net/detail/push_options.hpp" 26 | 27 | namespace std { 28 | namespace experimental { 29 | namespace net { 30 | namespace ip { 31 | 32 | std::string address_v6::to_string() const 33 | { 34 | std::error_code ec; 35 | std::string addr = to_string(ec); 36 | std::experimental::net::detail::throw_error(ec); 37 | return addr; 38 | } 39 | 40 | std::string address_v6::to_string(std::error_code& ec) const 41 | { 42 | char addr_str[std::experimental::net::detail::max_addr_v6_str_len]; 43 | const char* addr = 44 | std::experimental::net::detail::socket_ops::inet_ntop( 45 | AF_INET6, bytes_.data(), addr_str, 46 | std::experimental::net::detail::max_addr_v6_str_len, 47 | scope_id_, ec); 48 | if (addr == 0) 49 | return std::string(); 50 | return addr; 51 | } 52 | 53 | address_v6 make_address_v6(const char* str) 54 | { 55 | std::error_code ec; 56 | address_v6 addr = make_address_v6(str, ec); 57 | std::experimental::net::detail::throw_error(ec); 58 | return addr; 59 | } 60 | 61 | address_v6 make_address_v6(const char* str, 62 | std::error_code& ec) STDNET_NOEXCEPT 63 | { 64 | address_v6::bytes_type bytes; 65 | unsigned long scope_id = 0; 66 | if (std::experimental::net::detail::socket_ops::inet_pton( 67 | AF_INET6, str, bytes.data(), &scope_id, ec) <= 0) 68 | return address_v6(); 69 | return address_v6(bytes, scope_id); 70 | } 71 | 72 | address_v6 make_address_v6(const std::string& str) 73 | { 74 | return make_address_v6(str.c_str()); 75 | } 76 | 77 | address_v6 make_address_v6(const std::string& str, 78 | std::error_code& ec) STDNET_NOEXCEPT 79 | { 80 | return make_address_v6(str.c_str(), ec); 81 | } 82 | 83 | } // namespace ip 84 | } // namespace net 85 | } // namespace experimental 86 | } // namespace std 87 | 88 | #include "std/net/detail/pop_options.hpp" 89 | 90 | #endif // STDNET_IP_IMPL_ADDRESS_V6_IPP 91 | -------------------------------------------------------------------------------- /include/std/net/literals.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // literals.hpp 3 | // ~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef STDNET_LITERALS_HPP 12 | #define STDNET_LITERALS_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "std/net/ip/address.hpp" 19 | #include "std/net/ip/address_v4.hpp" 20 | #include "std/net/ip/address_v6.hpp" 21 | 22 | #include "std/net/detail/push_options.hpp" 23 | 24 | namespace std { 25 | namespace experimental { 26 | inline namespace literals { 27 | inline namespace net_literals { 28 | 29 | inline net::ip::address operator"" _ip(const char* str, std::size_t) 30 | { 31 | return net::ip::make_address(str); 32 | } 33 | 34 | inline net::ip::address_v4 operator"" _ipv4(const char* str, std::size_t) 35 | { 36 | return net::ip::make_address_v4(str); 37 | } 38 | 39 | inline net::ip::address_v6 operator"" _ipv6(const char* str, std::size_t) 40 | { 41 | return net::ip::make_address_v6(str); 42 | } 43 | 44 | } // inline namespace net_literals 45 | } // inline namespace literals 46 | } // namespace experimental 47 | } // namespace std 48 | 49 | #include "std/net/detail/pop_options.hpp" 50 | 51 | #endif // STDNET_LITERALS_HPP 52 | -------------------------------------------------------------------------------- /project-root.jam: -------------------------------------------------------------------------------- 1 | # This file intentionally left blank. 2 | -------------------------------------------------------------------------------- /tests/.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | network 3 | ip/address 4 | ip/address_v4 5 | ip/address_v6 6 | -------------------------------------------------------------------------------- /tests/Makefile: -------------------------------------------------------------------------------- 1 | ifndef CXXFLAGS 2 | CXXFLAGS = -std=c++11 -O2 -Wall -Wextra 3 | endif 4 | 5 | TESTS = \ 6 | network \ 7 | ip/address \ 8 | ip/address_v4 \ 9 | ip/address_v6 10 | 11 | OBJFILES = $(TESTS:%=%.o) 12 | 13 | all: $(TESTS) 14 | 15 | clean: 16 | rm -f $(OBJFILES) 17 | 18 | clobber: 19 | rm -f $(OBJFILES) $(TESTS) 20 | 21 | $(TESTS): %: %.o 22 | $(CXX) $(CXXFLAGS) -o $@ $< 23 | 24 | $(OBJFILES): %.o: %.cpp 25 | $(CXX) $(CXXFLAGS) -I../include -o $@ -c $< 26 | -------------------------------------------------------------------------------- /tests/ip/address.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // address.cpp 3 | // ~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | // Test that header file is self-contained. 12 | #include "std/net/ip/address.hpp" 13 | 14 | #include "../unit_test.hpp" 15 | #include 16 | 17 | //------------------------------------------------------------------------------ 18 | 19 | // ip_address_compile test 20 | // ~~~~~~~~~~~~~~~~~~~~~~~ 21 | // The following test checks that all public member functions on the class 22 | // ip::address compile and link correctly. Runtime failures are ignored. 23 | 24 | namespace ip_address_compile { 25 | 26 | void test() 27 | { 28 | namespace ip = std::experimental::net::ip; 29 | 30 | try 31 | { 32 | std::error_code ec; 33 | std::string string_value; 34 | 35 | // address constructors. 36 | 37 | ip::address addr1; 38 | const ip::address_v4 const_addr_v4; 39 | ip::address addr2(const_addr_v4); 40 | const ip::address_v6 const_addr_v6; 41 | ip::address addr3(const_addr_v6); 42 | ip::address addr4("127.0.0.1"); 43 | ip::address addr5("127.0.0.1", ec); 44 | ip::address addr6(string_value); 45 | ip::address addr7(string_value, ec); 46 | 47 | // address functions. 48 | 49 | bool b = addr1.is_v4(); 50 | (void)b; 51 | 52 | b = addr1.is_v6(); 53 | (void)b; 54 | 55 | b = addr1.is_loopback(); 56 | (void)b; 57 | 58 | b = addr1.is_unspecified(); 59 | (void)b; 60 | 61 | b = addr1.is_multicast(); 62 | (void)b; 63 | 64 | ip::address_v4 addr_v4_value = ip::address_cast(addr1); 65 | (void)addr_v4_value; 66 | 67 | ip::address_v6 addr_v6_value = ip::address_cast(addr1); 68 | (void)addr_v6_value; 69 | 70 | string_value = addr1.to_string(); 71 | string_value = addr1.to_string(ec); 72 | 73 | // address comparisons. 74 | 75 | b = (addr1 == addr2); 76 | (void)b; 77 | 78 | b = (addr1 != addr2); 79 | (void)b; 80 | 81 | b = (addr1 < addr2); 82 | (void)b; 83 | 84 | b = (addr1 > addr2); 85 | (void)b; 86 | 87 | b = (addr1 <= addr2); 88 | (void)b; 89 | 90 | b = (addr1 >= addr2); 91 | (void)b; 92 | 93 | // address creation functions. 94 | 95 | addr1 = ip::make_address("127.0.0.1"); 96 | addr1 = ip::make_address("127.0.0.1", ec); 97 | addr1 = ip::make_address(string_value); 98 | addr1 = ip::make_address(string_value, ec); 99 | 100 | // address I/O. 101 | 102 | std::ostringstream os; 103 | os << addr1; 104 | 105 | std::wostringstream wos; 106 | wos << addr1; 107 | } 108 | catch (std::exception&) 109 | { 110 | } 111 | } 112 | 113 | } // namespace ip_address_compile 114 | 115 | //------------------------------------------------------------------------------ 116 | 117 | STDNET_TEST_SUITE 118 | ( 119 | "ip/address", 120 | STDNET_TEST_CASE(ip_address_compile::test) 121 | ) 122 | -------------------------------------------------------------------------------- /tests/ip/address.dSYM/Contents/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.address 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /tests/ip/address.dSYM/Contents/Resources/DWARF/address: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chriskohlhoff/ip-address/38251ff2f9a2cb5e4152c7314e14d2e65e69f27d/tests/ip/address.dSYM/Contents/Resources/DWARF/address -------------------------------------------------------------------------------- /tests/ip/address_v4.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // address_v4.cpp 3 | // ~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | // Test that header file is self-contained. 12 | #include "std/net/ip/address_v4.hpp" 13 | 14 | #include "../unit_test.hpp" 15 | #include 16 | #include "std/net/ip/address_v6.hpp" 17 | 18 | //------------------------------------------------------------------------------ 19 | 20 | // ip_address_v4_compile test 21 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ 22 | // The following test checks that all public member functions on the class 23 | // ip::address_v4 compile and link correctly. Runtime failures are ignored. 24 | 25 | namespace ip_address_v4_compile { 26 | 27 | void test() 28 | { 29 | namespace ip = std::experimental::net::ip; 30 | 31 | try 32 | { 33 | std::error_code ec; 34 | std::string string_value; 35 | 36 | // address_v4 constructors. 37 | 38 | ip::address_v4 addr1; 39 | const ip::address_v4::bytes_type const_bytes_value(127, 0, 0, 1); 40 | ip::address_v4 addr2(const_bytes_value); 41 | const unsigned long const_ulong_value = 0x7F000001; 42 | ip::address_v4 addr3(const_ulong_value); 43 | ip::address_v4 addr4("127.0.0.1"); 44 | ip::address_v4 addr5("127.0.0.1", ec); 45 | ip::address_v4 addr6(string_value); 46 | ip::address_v4 addr7(string_value, ec); 47 | 48 | // address_v4 functions. 49 | 50 | bool b = addr1.is_loopback(); 51 | (void)b; 52 | 53 | b = addr1.is_unspecified(); 54 | (void)b; 55 | 56 | b = addr1.is_class_a(); 57 | (void)b; 58 | 59 | b = addr1.is_class_b(); 60 | (void)b; 61 | 62 | b = addr1.is_class_c(); 63 | (void)b; 64 | 65 | b = addr1.is_multicast(); 66 | (void)b; 67 | 68 | ip::address_v4::bytes_type bytes_value = addr1.to_bytes(); 69 | (void)bytes_value; 70 | 71 | unsigned long ulong_value = addr1.to_ulong(); 72 | (void)ulong_value; 73 | 74 | string_value = addr1.to_string(); 75 | string_value = addr1.to_string(ec); 76 | 77 | // address_v4 static functions. 78 | 79 | addr1 = ip::address_v4::any(); 80 | 81 | addr1 = ip::address_v4::loopback(); 82 | 83 | addr1 = ip::address_v4::broadcast(); 84 | 85 | addr1 = ip::address_v4::broadcast(addr2, addr3); 86 | 87 | // address_v4 comparisons. 88 | 89 | b = (addr1 == addr2); 90 | (void)b; 91 | 92 | b = (addr1 != addr2); 93 | (void)b; 94 | 95 | b = (addr1 < addr2); 96 | (void)b; 97 | 98 | b = (addr1 > addr2); 99 | (void)b; 100 | 101 | b = (addr1 <= addr2); 102 | (void)b; 103 | 104 | b = (addr1 >= addr2); 105 | (void)b; 106 | 107 | // address_v4 creation. 108 | 109 | addr1 = ip::make_address_v4(const_bytes_value); 110 | addr1 = ip::make_address_v4(const_ulong_value); 111 | addr1 = ip::make_address_v4(ip::v4_mapped, ip::address_v6()); 112 | addr1 = ip::make_address_v4("127.0.0.1"); 113 | addr1 = ip::make_address_v4("127.0.0.1", ec); 114 | addr1 = ip::make_address_v4(string_value); 115 | addr1 = ip::make_address_v4(string_value, ec); 116 | 117 | // address_v4 I/O. 118 | 119 | std::ostringstream os; 120 | os << addr1; 121 | 122 | std::wostringstream wos; 123 | wos << addr1; 124 | } 125 | catch (std::exception&) 126 | { 127 | } 128 | } 129 | 130 | } // namespace ip_address_v4_compile 131 | 132 | //------------------------------------------------------------------------------ 133 | 134 | // ip_address_v4_runtime test 135 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ 136 | // The following test checks that the various public member functions meet the 137 | // necessary postconditions. 138 | 139 | namespace ip_address_v4_runtime { 140 | 141 | void test() 142 | { 143 | using std::experimental::net::ip::address_v4; 144 | 145 | address_v4 a1; 146 | STDNET_CHECK(a1.to_bytes()[0] == 0); 147 | STDNET_CHECK(a1.to_bytes()[1] == 0); 148 | STDNET_CHECK(a1.to_bytes()[2] == 0); 149 | STDNET_CHECK(a1.to_bytes()[3] == 0); 150 | STDNET_CHECK(a1.to_ulong() == 0); 151 | 152 | address_v4::bytes_type b1(1, 2, 3, 4); 153 | address_v4 a2(b1); 154 | STDNET_CHECK(a2.to_bytes()[0] == 1); 155 | STDNET_CHECK(a2.to_bytes()[1] == 2); 156 | STDNET_CHECK(a2.to_bytes()[2] == 3); 157 | STDNET_CHECK(a2.to_bytes()[3] == 4); 158 | STDNET_CHECK(((a2.to_ulong() >> 24) & 0xFF) == b1[0]); 159 | STDNET_CHECK(((a2.to_ulong() >> 16) & 0xFF) == b1[1]); 160 | STDNET_CHECK(((a2.to_ulong() >> 8) & 0xFF) == b1[2]); 161 | STDNET_CHECK((a2.to_ulong() & 0xFF) == b1[3]); 162 | 163 | address_v4 a3(0x01020304); 164 | STDNET_CHECK(a3.to_bytes()[0] == 1); 165 | STDNET_CHECK(a3.to_bytes()[1] == 2); 166 | STDNET_CHECK(a3.to_bytes()[2] == 3); 167 | STDNET_CHECK(a3.to_bytes()[3] == 4); 168 | STDNET_CHECK(a3.to_ulong() == 0x01020304); 169 | 170 | STDNET_CHECK(address_v4(0x7F000001).is_loopback()); 171 | STDNET_CHECK(address_v4(0x7F000002).is_loopback()); 172 | STDNET_CHECK(!address_v4(0x00000000).is_loopback()); 173 | STDNET_CHECK(!address_v4(0x01020304).is_loopback()); 174 | 175 | STDNET_CHECK(address_v4(0x00000000).is_unspecified()); 176 | STDNET_CHECK(!address_v4(0x7F000001).is_unspecified()); 177 | STDNET_CHECK(!address_v4(0x01020304).is_unspecified()); 178 | 179 | STDNET_CHECK(address_v4(0x01000000).is_class_a()); 180 | STDNET_CHECK(address_v4(0x7F000000).is_class_a()); 181 | STDNET_CHECK(!address_v4(0x80000000).is_class_a()); 182 | STDNET_CHECK(!address_v4(0xBFFF0000).is_class_a()); 183 | STDNET_CHECK(!address_v4(0xC0000000).is_class_a()); 184 | STDNET_CHECK(!address_v4(0xDFFFFF00).is_class_a()); 185 | STDNET_CHECK(!address_v4(0xE0000000).is_class_a()); 186 | STDNET_CHECK(!address_v4(0xEFFFFFFF).is_class_a()); 187 | STDNET_CHECK(!address_v4(0xF0000000).is_class_a()); 188 | STDNET_CHECK(!address_v4(0xFFFFFFFF).is_class_a()); 189 | 190 | STDNET_CHECK(!address_v4(0x01000000).is_class_b()); 191 | STDNET_CHECK(!address_v4(0x7F000000).is_class_b()); 192 | STDNET_CHECK(address_v4(0x80000000).is_class_b()); 193 | STDNET_CHECK(address_v4(0xBFFF0000).is_class_b()); 194 | STDNET_CHECK(!address_v4(0xC0000000).is_class_b()); 195 | STDNET_CHECK(!address_v4(0xDFFFFF00).is_class_b()); 196 | STDNET_CHECK(!address_v4(0xE0000000).is_class_b()); 197 | STDNET_CHECK(!address_v4(0xEFFFFFFF).is_class_b()); 198 | STDNET_CHECK(!address_v4(0xF0000000).is_class_b()); 199 | STDNET_CHECK(!address_v4(0xFFFFFFFF).is_class_b()); 200 | 201 | STDNET_CHECK(!address_v4(0x01000000).is_class_c()); 202 | STDNET_CHECK(!address_v4(0x7F000000).is_class_c()); 203 | STDNET_CHECK(!address_v4(0x80000000).is_class_c()); 204 | STDNET_CHECK(!address_v4(0xBFFF0000).is_class_c()); 205 | STDNET_CHECK(address_v4(0xC0000000).is_class_c()); 206 | STDNET_CHECK(address_v4(0xDFFFFF00).is_class_c()); 207 | STDNET_CHECK(!address_v4(0xE0000000).is_class_c()); 208 | STDNET_CHECK(!address_v4(0xEFFFFFFF).is_class_c()); 209 | STDNET_CHECK(!address_v4(0xF0000000).is_class_c()); 210 | STDNET_CHECK(!address_v4(0xFFFFFFFF).is_class_c()); 211 | 212 | STDNET_CHECK(!address_v4(0x01000000).is_multicast()); 213 | STDNET_CHECK(!address_v4(0x7F000000).is_multicast()); 214 | STDNET_CHECK(!address_v4(0x80000000).is_multicast()); 215 | STDNET_CHECK(!address_v4(0xBFFF0000).is_multicast()); 216 | STDNET_CHECK(!address_v4(0xC0000000).is_multicast()); 217 | STDNET_CHECK(!address_v4(0xDFFFFF00).is_multicast()); 218 | STDNET_CHECK(address_v4(0xE0000000).is_multicast()); 219 | STDNET_CHECK(address_v4(0xEFFFFFFF).is_multicast()); 220 | STDNET_CHECK(!address_v4(0xF0000000).is_multicast()); 221 | STDNET_CHECK(!address_v4(0xFFFFFFFF).is_multicast()); 222 | 223 | address_v4 a4 = address_v4::any(); 224 | STDNET_CHECK(a4.to_bytes()[0] == 0); 225 | STDNET_CHECK(a4.to_bytes()[1] == 0); 226 | STDNET_CHECK(a4.to_bytes()[2] == 0); 227 | STDNET_CHECK(a4.to_bytes()[3] == 0); 228 | STDNET_CHECK(a4.to_ulong() == 0); 229 | 230 | address_v4 a5 = address_v4::loopback(); 231 | STDNET_CHECK(a5.to_bytes()[0] == 0x7F); 232 | STDNET_CHECK(a5.to_bytes()[1] == 0); 233 | STDNET_CHECK(a5.to_bytes()[2] == 0); 234 | STDNET_CHECK(a5.to_bytes()[3] == 0x01); 235 | STDNET_CHECK(a5.to_ulong() == 0x7F000001); 236 | 237 | address_v4 a6 = address_v4::broadcast(); 238 | STDNET_CHECK(a6.to_bytes()[0] == 0xFF); 239 | STDNET_CHECK(a6.to_bytes()[1] == 0xFF); 240 | STDNET_CHECK(a6.to_bytes()[2] == 0xFF); 241 | STDNET_CHECK(a6.to_bytes()[3] == 0xFF); 242 | STDNET_CHECK(a6.to_ulong() == 0xFFFFFFFF); 243 | } 244 | 245 | } // namespace ip_address_v4_runtime 246 | 247 | //------------------------------------------------------------------------------ 248 | 249 | STDNET_TEST_SUITE 250 | ( 251 | "ip/address_v4", 252 | STDNET_TEST_CASE(ip_address_v4_compile::test) 253 | STDNET_TEST_CASE(ip_address_v4_runtime::test) 254 | ) 255 | -------------------------------------------------------------------------------- /tests/ip/address_v6.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // address_v6.cpp 3 | // ~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | // Test that header file is self-contained. 12 | #include "std/net/ip/address_v6.hpp" 13 | 14 | #include "../unit_test.hpp" 15 | #include 16 | 17 | //------------------------------------------------------------------------------ 18 | 19 | // ip_address_v6_compile test 20 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ 21 | // The following test checks that all public member functions on the class 22 | // ip::address_v6 compile and link correctly. Runtime failures are ignored. 23 | 24 | namespace ip_address_v6_compile { 25 | 26 | void test() 27 | { 28 | namespace ip = std::experimental::net::ip; 29 | 30 | try 31 | { 32 | std::error_code ec; 33 | std::string string_value; 34 | 35 | // address_v6 constructors. 36 | 37 | ip::address_v6 addr1; 38 | const ip::address_v6::bytes_type const_bytes_value(0); 39 | ip::address_v6 addr2(const_bytes_value); 40 | ip::address_v6 addr3(const_bytes_value, 0); 41 | ip::address_v6 addr4("0::0"); 42 | ip::address_v6 addr5("0::0", ec); 43 | ip::address_v6 addr6(string_value); 44 | ip::address_v6 addr7(string_value, ec); 45 | 46 | // address_v6 functions. 47 | 48 | unsigned long scope_id = addr1.scope_id(); 49 | addr1.scope_id(scope_id); 50 | 51 | bool b = addr1.is_unspecified(); 52 | (void)b; 53 | 54 | b = addr1.is_loopback(); 55 | (void)b; 56 | 57 | b = addr1.is_multicast(); 58 | (void)b; 59 | 60 | b = addr1.is_link_local(); 61 | (void)b; 62 | 63 | b = addr1.is_site_local(); 64 | (void)b; 65 | 66 | b = addr1.is_v4_mapped(); 67 | (void)b; 68 | 69 | b = addr1.is_multicast_node_local(); 70 | (void)b; 71 | 72 | b = addr1.is_multicast_link_local(); 73 | (void)b; 74 | 75 | b = addr1.is_multicast_site_local(); 76 | (void)b; 77 | 78 | b = addr1.is_multicast_org_local(); 79 | (void)b; 80 | 81 | b = addr1.is_multicast_global(); 82 | (void)b; 83 | 84 | ip::address_v6::bytes_type bytes_value = addr1.to_bytes(); 85 | (void)bytes_value; 86 | 87 | string_value = addr1.to_string(); 88 | string_value = addr1.to_string(ec); 89 | 90 | // address_v6 static functions. 91 | 92 | addr1 = ip::address_v6::any(); 93 | 94 | addr1 = ip::address_v6::loopback(); 95 | 96 | // address_v6 comparisons. 97 | 98 | b = (addr1 == addr2); 99 | (void)b; 100 | 101 | b = (addr1 != addr2); 102 | (void)b; 103 | 104 | b = (addr1 < addr2); 105 | (void)b; 106 | 107 | b = (addr1 > addr2); 108 | (void)b; 109 | 110 | b = (addr1 <= addr2); 111 | (void)b; 112 | 113 | b = (addr1 >= addr2); 114 | (void)b; 115 | 116 | // address_v6 creation: 117 | 118 | addr1 = ip::make_address_v6(const_bytes_value); 119 | addr1 = ip::make_address_v6(const_bytes_value, 0); 120 | addr1 = ip::make_address_v6(ip::v4_mapped, ip::address_v4()); 121 | addr1 = ip::make_address_v6("0::0"); 122 | addr1 = ip::make_address_v6("0::0", ec); 123 | addr1 = ip::make_address_v6(string_value); 124 | addr1 = ip::make_address_v6(string_value, ec); 125 | 126 | // address_v6 I/O. 127 | 128 | std::ostringstream os; 129 | os << addr1; 130 | 131 | std::wostringstream wos; 132 | wos << addr1; 133 | } 134 | catch (std::exception&) 135 | { 136 | } 137 | } 138 | 139 | } // namespace ip_address_v6_compile 140 | 141 | //------------------------------------------------------------------------------ 142 | 143 | // ip_address_v6_runtime test 144 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ 145 | // The following test checks that the various public member functions meet the 146 | // necessary postconditions. 147 | 148 | namespace ip_address_v6_runtime { 149 | 150 | void test() 151 | { 152 | using std::experimental::net::ip::address_v6; 153 | 154 | address_v6 a1; 155 | STDNET_CHECK(a1.is_unspecified()); 156 | STDNET_CHECK(a1.scope_id() == 0); 157 | 158 | address_v6::bytes_type b1(1, 2, 3, 4, 5, 159 | 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); 160 | address_v6 a2(b1, 12345); 161 | STDNET_CHECK(a2.to_bytes()[0] == 1); 162 | STDNET_CHECK(a2.to_bytes()[1] == 2); 163 | STDNET_CHECK(a2.to_bytes()[2] == 3); 164 | STDNET_CHECK(a2.to_bytes()[3] == 4); 165 | STDNET_CHECK(a2.to_bytes()[4] == 5); 166 | STDNET_CHECK(a2.to_bytes()[5] == 6); 167 | STDNET_CHECK(a2.to_bytes()[6] == 7); 168 | STDNET_CHECK(a2.to_bytes()[7] == 8); 169 | STDNET_CHECK(a2.to_bytes()[8] == 9); 170 | STDNET_CHECK(a2.to_bytes()[9] == 10); 171 | STDNET_CHECK(a2.to_bytes()[10] == 11); 172 | STDNET_CHECK(a2.to_bytes()[11] == 12); 173 | STDNET_CHECK(a2.to_bytes()[12] == 13); 174 | STDNET_CHECK(a2.to_bytes()[13] == 14); 175 | STDNET_CHECK(a2.to_bytes()[14] == 15); 176 | STDNET_CHECK(a2.to_bytes()[15] == 16); 177 | STDNET_CHECK(a2.scope_id() == 12345); 178 | 179 | address_v6 a3; 180 | a3.scope_id(12345); 181 | STDNET_CHECK(a3.scope_id() == 12345); 182 | 183 | address_v6 unspecified_address; 184 | address_v6::bytes_type loopback_bytes(0); 185 | loopback_bytes[15] = 1; 186 | address_v6 loopback_address(loopback_bytes); 187 | address_v6::bytes_type link_local_bytes(0xFE, 0x80, 1); 188 | address_v6 link_local_address(link_local_bytes); 189 | address_v6::bytes_type site_local_bytes(0xFE, 0xC0, 1); 190 | address_v6 site_local_address(site_local_bytes); 191 | address_v6::bytes_type v4_mapped_bytes(0); 192 | v4_mapped_bytes[10] = 0xFF, v4_mapped_bytes[11] = 0xFF; 193 | v4_mapped_bytes[12] = 1, v4_mapped_bytes[13] = 2; 194 | v4_mapped_bytes[14] = 3, v4_mapped_bytes[15] = 4; 195 | address_v6 v4_mapped_address(v4_mapped_bytes); 196 | address_v6::bytes_type v4_compat_bytes(0); 197 | v4_compat_bytes[12] = 1, v4_compat_bytes[13] = 2; 198 | v4_compat_bytes[14] = 3, v4_compat_bytes[15] = 4; 199 | address_v6 v4_compat_address(v4_compat_bytes); 200 | address_v6::bytes_type mcast_global_bytes(0xFF, 0x0E, 1); 201 | address_v6 mcast_global_address(mcast_global_bytes); 202 | address_v6::bytes_type mcast_link_local_bytes(0xFF, 0x02, 1); 203 | address_v6 mcast_link_local_address(mcast_link_local_bytes); 204 | address_v6::bytes_type mcast_node_local_bytes(0xFF, 0x01, 1); 205 | address_v6 mcast_node_local_address(mcast_node_local_bytes); 206 | address_v6::bytes_type mcast_org_local_bytes(0xFF, 0x08, 1); 207 | address_v6 mcast_org_local_address(mcast_org_local_bytes); 208 | address_v6::bytes_type mcast_site_local_bytes(0xFF, 0x05, 1); 209 | address_v6 mcast_site_local_address(mcast_site_local_bytes); 210 | 211 | STDNET_CHECK(!unspecified_address.is_loopback()); 212 | STDNET_CHECK(loopback_address.is_loopback()); 213 | STDNET_CHECK(!link_local_address.is_loopback()); 214 | STDNET_CHECK(!site_local_address.is_loopback()); 215 | STDNET_CHECK(!v4_mapped_address.is_loopback()); 216 | STDNET_CHECK(!v4_compat_address.is_loopback()); 217 | STDNET_CHECK(!mcast_global_address.is_loopback()); 218 | STDNET_CHECK(!mcast_link_local_address.is_loopback()); 219 | STDNET_CHECK(!mcast_node_local_address.is_loopback()); 220 | STDNET_CHECK(!mcast_org_local_address.is_loopback()); 221 | STDNET_CHECK(!mcast_site_local_address.is_loopback()); 222 | 223 | STDNET_CHECK(unspecified_address.is_unspecified()); 224 | STDNET_CHECK(!loopback_address.is_unspecified()); 225 | STDNET_CHECK(!link_local_address.is_unspecified()); 226 | STDNET_CHECK(!site_local_address.is_unspecified()); 227 | STDNET_CHECK(!v4_mapped_address.is_unspecified()); 228 | STDNET_CHECK(!v4_compat_address.is_unspecified()); 229 | STDNET_CHECK(!mcast_global_address.is_unspecified()); 230 | STDNET_CHECK(!mcast_link_local_address.is_unspecified()); 231 | STDNET_CHECK(!mcast_node_local_address.is_unspecified()); 232 | STDNET_CHECK(!mcast_org_local_address.is_unspecified()); 233 | STDNET_CHECK(!mcast_site_local_address.is_unspecified()); 234 | 235 | STDNET_CHECK(!unspecified_address.is_link_local()); 236 | STDNET_CHECK(!loopback_address.is_link_local()); 237 | STDNET_CHECK(link_local_address.is_link_local()); 238 | STDNET_CHECK(!site_local_address.is_link_local()); 239 | STDNET_CHECK(!v4_mapped_address.is_link_local()); 240 | STDNET_CHECK(!v4_compat_address.is_link_local()); 241 | STDNET_CHECK(!mcast_global_address.is_link_local()); 242 | STDNET_CHECK(!mcast_link_local_address.is_link_local()); 243 | STDNET_CHECK(!mcast_node_local_address.is_link_local()); 244 | STDNET_CHECK(!mcast_org_local_address.is_link_local()); 245 | STDNET_CHECK(!mcast_site_local_address.is_link_local()); 246 | 247 | STDNET_CHECK(!unspecified_address.is_site_local()); 248 | STDNET_CHECK(!loopback_address.is_site_local()); 249 | STDNET_CHECK(!link_local_address.is_site_local()); 250 | STDNET_CHECK(site_local_address.is_site_local()); 251 | STDNET_CHECK(!v4_mapped_address.is_site_local()); 252 | STDNET_CHECK(!v4_compat_address.is_site_local()); 253 | STDNET_CHECK(!mcast_global_address.is_site_local()); 254 | STDNET_CHECK(!mcast_link_local_address.is_site_local()); 255 | STDNET_CHECK(!mcast_node_local_address.is_site_local()); 256 | STDNET_CHECK(!mcast_org_local_address.is_site_local()); 257 | STDNET_CHECK(!mcast_site_local_address.is_site_local()); 258 | 259 | STDNET_CHECK(!unspecified_address.is_v4_mapped()); 260 | STDNET_CHECK(!loopback_address.is_v4_mapped()); 261 | STDNET_CHECK(!link_local_address.is_v4_mapped()); 262 | STDNET_CHECK(!site_local_address.is_v4_mapped()); 263 | STDNET_CHECK(v4_mapped_address.is_v4_mapped()); 264 | STDNET_CHECK(!v4_compat_address.is_v4_mapped()); 265 | STDNET_CHECK(!mcast_global_address.is_v4_mapped()); 266 | STDNET_CHECK(!mcast_link_local_address.is_v4_mapped()); 267 | STDNET_CHECK(!mcast_node_local_address.is_v4_mapped()); 268 | STDNET_CHECK(!mcast_org_local_address.is_v4_mapped()); 269 | STDNET_CHECK(!mcast_site_local_address.is_v4_mapped()); 270 | 271 | STDNET_CHECK(!unspecified_address.is_multicast()); 272 | STDNET_CHECK(!loopback_address.is_multicast()); 273 | STDNET_CHECK(!link_local_address.is_multicast()); 274 | STDNET_CHECK(!site_local_address.is_multicast()); 275 | STDNET_CHECK(!v4_mapped_address.is_multicast()); 276 | STDNET_CHECK(!v4_compat_address.is_multicast()); 277 | STDNET_CHECK(mcast_global_address.is_multicast()); 278 | STDNET_CHECK(mcast_link_local_address.is_multicast()); 279 | STDNET_CHECK(mcast_node_local_address.is_multicast()); 280 | STDNET_CHECK(mcast_org_local_address.is_multicast()); 281 | STDNET_CHECK(mcast_site_local_address.is_multicast()); 282 | 283 | STDNET_CHECK(!unspecified_address.is_multicast_global()); 284 | STDNET_CHECK(!loopback_address.is_multicast_global()); 285 | STDNET_CHECK(!link_local_address.is_multicast_global()); 286 | STDNET_CHECK(!site_local_address.is_multicast_global()); 287 | STDNET_CHECK(!v4_mapped_address.is_multicast_global()); 288 | STDNET_CHECK(!v4_compat_address.is_multicast_global()); 289 | STDNET_CHECK(mcast_global_address.is_multicast_global()); 290 | STDNET_CHECK(!mcast_link_local_address.is_multicast_global()); 291 | STDNET_CHECK(!mcast_node_local_address.is_multicast_global()); 292 | STDNET_CHECK(!mcast_org_local_address.is_multicast_global()); 293 | STDNET_CHECK(!mcast_site_local_address.is_multicast_global()); 294 | 295 | STDNET_CHECK(!unspecified_address.is_multicast_link_local()); 296 | STDNET_CHECK(!loopback_address.is_multicast_link_local()); 297 | STDNET_CHECK(!link_local_address.is_multicast_link_local()); 298 | STDNET_CHECK(!site_local_address.is_multicast_link_local()); 299 | STDNET_CHECK(!v4_mapped_address.is_multicast_link_local()); 300 | STDNET_CHECK(!v4_compat_address.is_multicast_link_local()); 301 | STDNET_CHECK(!mcast_global_address.is_multicast_link_local()); 302 | STDNET_CHECK(mcast_link_local_address.is_multicast_link_local()); 303 | STDNET_CHECK(!mcast_node_local_address.is_multicast_link_local()); 304 | STDNET_CHECK(!mcast_org_local_address.is_multicast_link_local()); 305 | STDNET_CHECK(!mcast_site_local_address.is_multicast_link_local()); 306 | 307 | STDNET_CHECK(!unspecified_address.is_multicast_node_local()); 308 | STDNET_CHECK(!loopback_address.is_multicast_node_local()); 309 | STDNET_CHECK(!link_local_address.is_multicast_node_local()); 310 | STDNET_CHECK(!site_local_address.is_multicast_node_local()); 311 | STDNET_CHECK(!v4_mapped_address.is_multicast_node_local()); 312 | STDNET_CHECK(!v4_compat_address.is_multicast_node_local()); 313 | STDNET_CHECK(!mcast_global_address.is_multicast_node_local()); 314 | STDNET_CHECK(!mcast_link_local_address.is_multicast_node_local()); 315 | STDNET_CHECK(mcast_node_local_address.is_multicast_node_local()); 316 | STDNET_CHECK(!mcast_org_local_address.is_multicast_node_local()); 317 | STDNET_CHECK(!mcast_site_local_address.is_multicast_node_local()); 318 | 319 | STDNET_CHECK(!unspecified_address.is_multicast_org_local()); 320 | STDNET_CHECK(!loopback_address.is_multicast_org_local()); 321 | STDNET_CHECK(!link_local_address.is_multicast_org_local()); 322 | STDNET_CHECK(!site_local_address.is_multicast_org_local()); 323 | STDNET_CHECK(!v4_mapped_address.is_multicast_org_local()); 324 | STDNET_CHECK(!v4_compat_address.is_multicast_org_local()); 325 | STDNET_CHECK(!mcast_global_address.is_multicast_org_local()); 326 | STDNET_CHECK(!mcast_link_local_address.is_multicast_org_local()); 327 | STDNET_CHECK(!mcast_node_local_address.is_multicast_org_local()); 328 | STDNET_CHECK(mcast_org_local_address.is_multicast_org_local()); 329 | STDNET_CHECK(!mcast_site_local_address.is_multicast_org_local()); 330 | 331 | STDNET_CHECK(!unspecified_address.is_multicast_site_local()); 332 | STDNET_CHECK(!loopback_address.is_multicast_site_local()); 333 | STDNET_CHECK(!link_local_address.is_multicast_site_local()); 334 | STDNET_CHECK(!site_local_address.is_multicast_site_local()); 335 | STDNET_CHECK(!v4_mapped_address.is_multicast_site_local()); 336 | STDNET_CHECK(!v4_compat_address.is_multicast_site_local()); 337 | STDNET_CHECK(!mcast_global_address.is_multicast_site_local()); 338 | STDNET_CHECK(!mcast_link_local_address.is_multicast_site_local()); 339 | STDNET_CHECK(!mcast_node_local_address.is_multicast_site_local()); 340 | STDNET_CHECK(!mcast_org_local_address.is_multicast_site_local()); 341 | STDNET_CHECK(mcast_site_local_address.is_multicast_site_local()); 342 | 343 | STDNET_CHECK(address_v6::loopback().is_loopback()); 344 | } 345 | 346 | } // namespace ip_address_v6_runtime 347 | 348 | //------------------------------------------------------------------------------ 349 | 350 | STDNET_TEST_SUITE 351 | ( 352 | "ip/address_v6", 353 | STDNET_TEST_CASE(ip_address_v6_compile::test) 354 | STDNET_TEST_CASE(ip_address_v6_runtime::test) 355 | ) 356 | -------------------------------------------------------------------------------- /tests/network.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // network.cpp 3 | // ~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | // Test that header file is self-contained. 12 | #include 13 | 14 | #include "unit_test.hpp" 15 | 16 | //------------------------------------------------------------------------------ 17 | 18 | STDNET_TEST_SUITE 19 | ( 20 | "network", 21 | STDNET_TEST_CASE(null_test) 22 | ) 23 | -------------------------------------------------------------------------------- /tests/unit_test.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // unit_test.hpp 3 | // ~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef UNIT_TEST_HPP 12 | #define UNIT_TEST_HPP 13 | 14 | #include "std/net/detail/config.hpp" 15 | 16 | #if defined(__sun) 17 | # include // Needed for lrand48. 18 | #endif // defined(__sun) 19 | 20 | #if defined(__BORLANDC__) 21 | 22 | // Prevent use of intrinsic for strcmp. 23 | # include 24 | # undef strcmp 25 | 26 | // Suppress error about condition always being true. 27 | # pragma option -w-ccc 28 | 29 | #endif // defined(__BORLANDC__) 30 | 31 | #if defined(STDNET_MSVC) 32 | # pragma warning (push) 33 | # pragma warning (disable:4244) 34 | # pragma warning (disable:4702) 35 | #endif // defined(STDNET_MSVC) 36 | 37 | #include 38 | #include 39 | 40 | #if defined(NDEBUG) 41 | # error NDEBUG must not be defined when building these unit tests 42 | #endif // defined(NDEBUG) 43 | 44 | #define STDNET_CHECK(expr) assert(expr) 45 | 46 | #define STDNET_CHECK_MESSAGE(expr, message) \ 47 | do { if (!(expr)) { std::cout << message << std::endl; assert(expr); } } while (0) 48 | 49 | #define STDNET_WARN_MESSAGE(expr, message) \ 50 | do { if (!(expr)) { std::cout << message << std::endl; } } while (0) 51 | 52 | #define STDNET_ERROR(message) assert(0 && message) 53 | 54 | #define STDNET_TEST_SUITE(name, tests) \ 55 | int main() \ 56 | { \ 57 | std::cout << name << " test suite begins" << std::endl; \ 58 | tests \ 59 | std::cout << name << " test suite ends" << std::endl; \ 60 | return 0; \ 61 | } 62 | 63 | #define STDNET_TEST_CASE(test) \ 64 | test(); \ 65 | std::cout << #test << " passed" << std::endl; 66 | 67 | #if defined(STDNET_MSVC) 68 | # pragma warning (pop) 69 | #endif // defined(STDNET_MSVC) 70 | 71 | inline void null_test() 72 | { 73 | } 74 | 75 | #endif // UNIT_TEST_HPP 76 | --------------------------------------------------------------------------------