summaryrefslogtreecommitdiffstats
path: root/lib/asio/ip/impl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/asio/ip/impl')
-rw-r--r--lib/asio/ip/impl/address.hpp67
-rw-r--r--lib/asio/ip/impl/address.ipp234
-rw-r--r--lib/asio/ip/impl/address_v4.hpp67
-rw-r--r--lib/asio/ip/impl/address_v4.ipp210
-rw-r--r--lib/asio/ip/impl/address_v6.hpp67
-rw-r--r--lib/asio/ip/impl/address_v6.ipp350
-rw-r--r--lib/asio/ip/impl/basic_endpoint.hpp43
-rw-r--r--lib/asio/ip/impl/host_name.ipp54
-rw-r--r--lib/asio/ip/impl/network_v4.hpp54
-rw-r--r--lib/asio/ip/impl/network_v4.ipp216
-rw-r--r--lib/asio/ip/impl/network_v6.hpp53
-rw-r--r--lib/asio/ip/impl/network_v6.ipp185
12 files changed, 1600 insertions, 0 deletions
diff --git a/lib/asio/ip/impl/address.hpp b/lib/asio/ip/impl/address.hpp
new file mode 100644
index 0000000..085b93f
--- /dev/null
+++ b/lib/asio/ip/impl/address.hpp
@@ -0,0 +1,67 @@
+//
+// ip/impl/address.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_ADDRESS_HPP
+#define ASIO_IP_IMPL_ADDRESS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+inline address address::from_string(const char* str)
+{
+ return asio::ip::make_address(str);
+}
+
+inline address address::from_string(
+ const char* str, asio::error_code& ec)
+{
+ return asio::ip::make_address(str, ec);
+}
+
+inline address address::from_string(const std::string& str)
+{
+ return asio::ip::make_address(str);
+}
+
+inline address address::from_string(
+ const std::string& str, asio::error_code& ec)
+{
+ return asio::ip::make_address(str, ec);
+}
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& os, const address& addr)
+{
+ return os << addr.to_string().c_str();
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_ADDRESS_HPP
diff --git a/lib/asio/ip/impl/address.ipp b/lib/asio/ip/impl/address.ipp
new file mode 100644
index 0000000..0523071
--- /dev/null
+++ b/lib/asio/ip/impl/address.ipp
@@ -0,0 +1,234 @@
+//
+// ip/impl/address.ipp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_ADDRESS_IPP
+#define ASIO_IP_IMPL_ADDRESS_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <typeinfo>
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/error.hpp"
+#include "asio/ip/address.hpp"
+#include "asio/ip/bad_address_cast.hpp"
+#include "asio/system_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+address::address()
+ : type_(ipv4),
+ ipv4_address_(),
+ ipv6_address_()
+{
+}
+
+address::address(const asio::ip::address_v4& ipv4_address)
+ : type_(ipv4),
+ ipv4_address_(ipv4_address),
+ ipv6_address_()
+{
+}
+
+address::address(const asio::ip::address_v6& ipv6_address)
+ : type_(ipv6),
+ ipv4_address_(),
+ ipv6_address_(ipv6_address)
+{
+}
+
+address::address(const address& other)
+ : type_(other.type_),
+ ipv4_address_(other.ipv4_address_),
+ ipv6_address_(other.ipv6_address_)
+{
+}
+
+#if defined(ASIO_HAS_MOVE)
+address::address(address&& other)
+ : type_(other.type_),
+ ipv4_address_(other.ipv4_address_),
+ ipv6_address_(other.ipv6_address_)
+{
+}
+#endif // defined(ASIO_HAS_MOVE)
+
+address& address::operator=(const address& other)
+{
+ type_ = other.type_;
+ ipv4_address_ = other.ipv4_address_;
+ ipv6_address_ = other.ipv6_address_;
+ return *this;
+}
+
+#if defined(ASIO_HAS_MOVE)
+address& address::operator=(address&& other)
+{
+ type_ = other.type_;
+ ipv4_address_ = other.ipv4_address_;
+ ipv6_address_ = other.ipv6_address_;
+ return *this;
+}
+#endif // defined(ASIO_HAS_MOVE)
+
+address& address::operator=(const asio::ip::address_v4& ipv4_address)
+{
+ type_ = ipv4;
+ ipv4_address_ = ipv4_address;
+ ipv6_address_ = asio::ip::address_v6();
+ return *this;
+}
+
+address& address::operator=(const asio::ip::address_v6& ipv6_address)
+{
+ type_ = ipv6;
+ ipv4_address_ = asio::ip::address_v4();
+ ipv6_address_ = ipv6_address;
+ return *this;
+}
+
+address make_address(const char* str)
+{
+ asio::error_code ec;
+ address addr = make_address(str, ec);
+ asio::detail::throw_error(ec);
+ return addr;
+}
+
+address make_address(const char* str, asio::error_code& ec)
+{
+ asio::ip::address_v6 ipv6_address =
+ asio::ip::make_address_v6(str, ec);
+ if (!ec)
+ return address(ipv6_address);
+
+ asio::ip::address_v4 ipv4_address =
+ asio::ip::make_address_v4(str, ec);
+ if (!ec)
+ return address(ipv4_address);
+
+ return address();
+}
+
+address make_address(const std::string& str)
+{
+ return make_address(str.c_str());
+}
+
+address make_address(const std::string& str,
+ asio::error_code& ec)
+{
+ return make_address(str.c_str(), ec);
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+address make_address(string_view str)
+{
+ return make_address(static_cast<std::string>(str));
+}
+
+address make_address(string_view str,
+ asio::error_code& ec)
+{
+ return make_address(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+asio::ip::address_v4 address::to_v4() const
+{
+ if (type_ != ipv4)
+ {
+ bad_address_cast ex;
+ asio::detail::throw_exception(ex);
+ }
+ return ipv4_address_;
+}
+
+asio::ip::address_v6 address::to_v6() const
+{
+ if (type_ != ipv6)
+ {
+ bad_address_cast ex;
+ asio::detail::throw_exception(ex);
+ }
+ return ipv6_address_;
+}
+
+std::string address::to_string() const
+{
+ if (type_ == ipv6)
+ return ipv6_address_.to_string();
+ return ipv4_address_.to_string();
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+std::string address::to_string(asio::error_code& ec) const
+{
+ if (type_ == ipv6)
+ return ipv6_address_.to_string(ec);
+ return ipv4_address_.to_string(ec);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+bool address::is_loopback() const
+{
+ return (type_ == ipv4)
+ ? ipv4_address_.is_loopback()
+ : ipv6_address_.is_loopback();
+}
+
+bool address::is_unspecified() const
+{
+ return (type_ == ipv4)
+ ? ipv4_address_.is_unspecified()
+ : ipv6_address_.is_unspecified();
+}
+
+bool address::is_multicast() const
+{
+ return (type_ == ipv4)
+ ? ipv4_address_.is_multicast()
+ : ipv6_address_.is_multicast();
+}
+
+bool operator==(const address& a1, const address& a2)
+{
+ if (a1.type_ != a2.type_)
+ return false;
+ if (a1.type_ == address::ipv6)
+ return a1.ipv6_address_ == a2.ipv6_address_;
+ return a1.ipv4_address_ == a2.ipv4_address_;
+}
+
+bool operator<(const address& a1, const address& a2)
+{
+ if (a1.type_ < a2.type_)
+ return true;
+ if (a1.type_ > a2.type_)
+ return false;
+ if (a1.type_ == address::ipv6)
+ return a1.ipv6_address_ < a2.ipv6_address_;
+ return a1.ipv4_address_ < a2.ipv4_address_;
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_ADDRESS_IPP
diff --git a/lib/asio/ip/impl/address_v4.hpp b/lib/asio/ip/impl/address_v4.hpp
new file mode 100644
index 0000000..d1cf407
--- /dev/null
+++ b/lib/asio/ip/impl/address_v4.hpp
@@ -0,0 +1,67 @@
+//
+// ip/impl/address_v4.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_ADDRESS_V4_HPP
+#define ASIO_IP_IMPL_ADDRESS_V4_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+inline address_v4 address_v4::from_string(const char* str)
+{
+ return asio::ip::make_address_v4(str);
+}
+
+inline address_v4 address_v4::from_string(
+ const char* str, asio::error_code& ec)
+{
+ return asio::ip::make_address_v4(str, ec);
+}
+
+inline address_v4 address_v4::from_string(const std::string& str)
+{
+ return asio::ip::make_address_v4(str);
+}
+
+inline address_v4 address_v4::from_string(
+ const std::string& str, asio::error_code& ec)
+{
+ return asio::ip::make_address_v4(str, ec);
+}
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
+{
+ return os << addr.to_string().c_str();
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_ADDRESS_V4_HPP
diff --git a/lib/asio/ip/impl/address_v4.ipp b/lib/asio/ip/impl/address_v4.ipp
new file mode 100644
index 0000000..9559add
--- /dev/null
+++ b/lib/asio/ip/impl/address_v4.ipp
@@ -0,0 +1,210 @@
+//
+// ip/impl/address_v4.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_ADDRESS_V4_IPP
+#define ASIO_IP_IMPL_ADDRESS_V4_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <climits>
+#include <limits>
+#include <stdexcept>
+#include "asio/error.hpp"
+#include "asio/detail/socket_ops.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/ip/address_v4.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+address_v4::address_v4(const address_v4::bytes_type& bytes)
+{
+#if UCHAR_MAX > 0xFF
+ if (bytes[0] > 0xFF || bytes[1] > 0xFF
+ || bytes[2] > 0xFF || bytes[3] > 0xFF)
+ {
+ std::out_of_range ex("address_v4 from bytes_type");
+ asio::detail::throw_exception(ex);
+ }
+#endif // UCHAR_MAX > 0xFF
+
+ using namespace std; // For memcpy.
+ memcpy(&addr_.s_addr, bytes.data(), 4);
+}
+
+address_v4::address_v4(address_v4::uint_type addr)
+{
+ if ((std::numeric_limits<uint_type>::max)() > 0xFFFFFFFF)
+ {
+ std::out_of_range ex("address_v4 from unsigned integer");
+ asio::detail::throw_exception(ex);
+ }
+
+ addr_.s_addr = asio::detail::socket_ops::host_to_network_long(
+ static_cast<asio::detail::u_long_type>(addr));
+}
+
+address_v4::bytes_type address_v4::to_bytes() const
+{
+ using namespace std; // For memcpy.
+ bytes_type bytes;
+#if defined(ASIO_HAS_STD_ARRAY)
+ memcpy(bytes.data(), &addr_.s_addr, 4);
+#else // defined(ASIO_HAS_STD_ARRAY)
+ memcpy(bytes.elems, &addr_.s_addr, 4);
+#endif // defined(ASIO_HAS_STD_ARRAY)
+ return bytes;
+}
+
+address_v4::uint_type address_v4::to_uint() const
+{
+ return asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+unsigned long address_v4::to_ulong() const
+{
+ return asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+std::string address_v4::to_string() const
+{
+ asio::error_code ec;
+ char addr_str[asio::detail::max_addr_v4_str_len];
+ const char* addr =
+ asio::detail::socket_ops::inet_ntop(
+ ASIO_OS_DEF(AF_INET), &addr_, addr_str,
+ asio::detail::max_addr_v4_str_len, 0, ec);
+ if (addr == 0)
+ asio::detail::throw_error(ec);
+ return addr;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+std::string address_v4::to_string(asio::error_code& ec) const
+{
+ char addr_str[asio::detail::max_addr_v4_str_len];
+ const char* addr =
+ asio::detail::socket_ops::inet_ntop(
+ ASIO_OS_DEF(AF_INET), &addr_, addr_str,
+ asio::detail::max_addr_v4_str_len, 0, ec);
+ if (addr == 0)
+ return std::string();
+ return addr;
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+bool address_v4::is_loopback() const
+{
+ return (to_uint() & 0xFF000000) == 0x7F000000;
+}
+
+bool address_v4::is_unspecified() const
+{
+ return to_uint() == 0;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+bool address_v4::is_class_a() const
+{
+ return (to_uint() & 0x80000000) == 0;
+}
+
+bool address_v4::is_class_b() const
+{
+ return (to_uint() & 0xC0000000) == 0x80000000;
+}
+
+bool address_v4::is_class_c() const
+{
+ return (to_uint() & 0xE0000000) == 0xC0000000;
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+bool address_v4::is_multicast() const
+{
+ return (to_uint() & 0xF0000000) == 0xE0000000;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
+{
+ return address_v4(addr.to_uint() | (mask.to_uint() ^ 0xFFFFFFFF));
+}
+
+address_v4 address_v4::netmask(const address_v4& addr)
+{
+ if (addr.is_class_a())
+ return address_v4(0xFF000000);
+ if (addr.is_class_b())
+ return address_v4(0xFFFF0000);
+ if (addr.is_class_c())
+ return address_v4(0xFFFFFF00);
+ return address_v4(0xFFFFFFFF);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+address_v4 make_address_v4(const char* str)
+{
+ asio::error_code ec;
+ address_v4 addr = make_address_v4(str, ec);
+ asio::detail::throw_error(ec);
+ return addr;
+}
+
+address_v4 make_address_v4(
+ const char* str, asio::error_code& ec)
+{
+ address_v4::bytes_type bytes;
+ if (asio::detail::socket_ops::inet_pton(
+ ASIO_OS_DEF(AF_INET), str, &bytes, 0, ec) <= 0)
+ return address_v4();
+ return address_v4(bytes);
+}
+
+address_v4 make_address_v4(const std::string& str)
+{
+ return make_address_v4(str.c_str());
+}
+
+address_v4 make_address_v4(
+ const std::string& str, asio::error_code& ec)
+{
+ return make_address_v4(str.c_str(), ec);
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+address_v4 make_address_v4(string_view str)
+{
+ return make_address_v4(static_cast<std::string>(str));
+}
+
+address_v4 make_address_v4(string_view str,
+ asio::error_code& ec)
+{
+ return make_address_v4(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_ADDRESS_V4_IPP
diff --git a/lib/asio/ip/impl/address_v6.hpp b/lib/asio/ip/impl/address_v6.hpp
new file mode 100644
index 0000000..330eafd
--- /dev/null
+++ b/lib/asio/ip/impl/address_v6.hpp
@@ -0,0 +1,67 @@
+//
+// ip/impl/address_v6.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_ADDRESS_V6_HPP
+#define ASIO_IP_IMPL_ADDRESS_V6_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+inline address_v6 address_v6::from_string(const char* str)
+{
+ return asio::ip::make_address_v6(str);
+}
+
+inline address_v6 address_v6::from_string(
+ const char* str, asio::error_code& ec)
+{
+ return asio::ip::make_address_v6(str, ec);
+}
+
+inline address_v6 address_v6::from_string(const std::string& str)
+{
+ return asio::ip::make_address_v6(str);
+}
+
+inline address_v6 address_v6::from_string(
+ const std::string& str, asio::error_code& ec)
+{
+ return asio::ip::make_address_v6(str, ec);
+}
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
+{
+ return os << addr.to_string().c_str();
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_ADDRESS_V6_HPP
diff --git a/lib/asio/ip/impl/address_v6.ipp b/lib/asio/ip/impl/address_v6.ipp
new file mode 100644
index 0000000..36bd68c
--- /dev/null
+++ b/lib/asio/ip/impl/address_v6.ipp
@@ -0,0 +1,350 @@
+//
+// ip/impl/address_v6.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_ADDRESS_V6_IPP
+#define ASIO_IP_IMPL_ADDRESS_V6_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <cstring>
+#include <stdexcept>
+#include <typeinfo>
+#include "asio/detail/socket_ops.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/error.hpp"
+#include "asio/ip/address_v6.hpp"
+#include "asio/ip/bad_address_cast.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+address_v6::address_v6()
+ : addr_(),
+ scope_id_(0)
+{
+}
+
+address_v6::address_v6(const address_v6::bytes_type& bytes,
+ unsigned long scope)
+ : scope_id_(scope)
+{
+#if UCHAR_MAX > 0xFF
+ for (std::size_t i = 0; i < bytes.size(); ++i)
+ {
+ if (bytes[i] > 0xFF)
+ {
+ std::out_of_range ex("address_v6 from bytes_type");
+ asio::detail::throw_exception(ex);
+ }
+ }
+#endif // UCHAR_MAX > 0xFF
+
+ using namespace std; // For memcpy.
+ memcpy(addr_.s6_addr, bytes.data(), 16);
+}
+
+address_v6::address_v6(const address_v6& other)
+ : addr_(other.addr_),
+ scope_id_(other.scope_id_)
+{
+}
+
+#if defined(ASIO_HAS_MOVE)
+address_v6::address_v6(address_v6&& other)
+ : addr_(other.addr_),
+ scope_id_(other.scope_id_)
+{
+}
+#endif // defined(ASIO_HAS_MOVE)
+
+address_v6& address_v6::operator=(const address_v6& other)
+{
+ addr_ = other.addr_;
+ scope_id_ = other.scope_id_;
+ return *this;
+}
+
+#if defined(ASIO_HAS_MOVE)
+address_v6& address_v6::operator=(address_v6&& other)
+{
+ addr_ = other.addr_;
+ scope_id_ = other.scope_id_;
+ return *this;
+}
+#endif // defined(ASIO_HAS_MOVE)
+
+address_v6::bytes_type address_v6::to_bytes() const
+{
+ using namespace std; // For memcpy.
+ bytes_type bytes;
+#if defined(ASIO_HAS_STD_ARRAY)
+ memcpy(bytes.data(), addr_.s6_addr, 16);
+#else // defined(ASIO_HAS_STD_ARRAY)
+ memcpy(bytes.elems, addr_.s6_addr, 16);
+#endif // defined(ASIO_HAS_STD_ARRAY)
+ return bytes;
+}
+
+std::string address_v6::to_string() const
+{
+ asio::error_code ec;
+ char addr_str[asio::detail::max_addr_v6_str_len];
+ const char* addr =
+ asio::detail::socket_ops::inet_ntop(
+ ASIO_OS_DEF(AF_INET6), &addr_, addr_str,
+ asio::detail::max_addr_v6_str_len, scope_id_, ec);
+ if (addr == 0)
+ asio::detail::throw_error(ec);
+ return addr;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+std::string address_v6::to_string(asio::error_code& ec) const
+{
+ char addr_str[asio::detail::max_addr_v6_str_len];
+ const char* addr =
+ asio::detail::socket_ops::inet_ntop(
+ ASIO_OS_DEF(AF_INET6), &addr_, addr_str,
+ asio::detail::max_addr_v6_str_len, scope_id_, ec);
+ if (addr == 0)
+ return std::string();
+ return addr;
+}
+
+address_v4 address_v6::to_v4() const
+{
+ if (!is_v4_mapped() && !is_v4_compatible())
+ {
+ bad_address_cast ex;
+ asio::detail::throw_exception(ex);
+ }
+
+ address_v4::bytes_type v4_bytes = { { addr_.s6_addr[12],
+ addr_.s6_addr[13], addr_.s6_addr[14], addr_.s6_addr[15] } };
+ return address_v4(v4_bytes);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+bool address_v6::is_loopback() const
+{
+ return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
+ && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
+ && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
+ && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
+ && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
+ && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
+ && (addr_.s6_addr[12] == 0) && (addr_.s6_addr[13] == 0)
+ && (addr_.s6_addr[14] == 0) && (addr_.s6_addr[15] == 1));
+}
+
+bool address_v6::is_unspecified() const
+{
+ return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
+ && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
+ && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
+ && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
+ && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
+ && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
+ && (addr_.s6_addr[12] == 0) && (addr_.s6_addr[13] == 0)
+ && (addr_.s6_addr[14] == 0) && (addr_.s6_addr[15] == 0));
+}
+
+bool address_v6::is_link_local() const
+{
+ return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0x80));
+}
+
+bool address_v6::is_site_local() const
+{
+ return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0xc0));
+}
+
+bool address_v6::is_v4_mapped() const
+{
+ return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
+ && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
+ && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
+ && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
+ && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
+ && (addr_.s6_addr[10] == 0xff) && (addr_.s6_addr[11] == 0xff));
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+bool address_v6::is_v4_compatible() const
+{
+ return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
+ && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
+ && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
+ && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
+ && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
+ && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
+ && !((addr_.s6_addr[12] == 0)
+ && (addr_.s6_addr[13] == 0)
+ && (addr_.s6_addr[14] == 0)
+ && ((addr_.s6_addr[15] == 0) || (addr_.s6_addr[15] == 1))));
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+bool address_v6::is_multicast() const
+{
+ return (addr_.s6_addr[0] == 0xff);
+}
+
+bool address_v6::is_multicast_global() const
+{
+ return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x0e));
+}
+
+bool address_v6::is_multicast_link_local() const
+{
+ return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x02));
+}
+
+bool address_v6::is_multicast_node_local() const
+{
+ return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x01));
+}
+
+bool address_v6::is_multicast_org_local() const
+{
+ return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x08));
+}
+
+bool address_v6::is_multicast_site_local() const
+{
+ return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x05));
+}
+
+bool operator==(const address_v6& a1, const address_v6& a2)
+{
+ using namespace std; // For memcmp.
+ return memcmp(&a1.addr_, &a2.addr_,
+ sizeof(asio::detail::in6_addr_type)) == 0
+ && a1.scope_id_ == a2.scope_id_;
+}
+
+bool operator<(const address_v6& a1, const address_v6& a2)
+{
+ using namespace std; // For memcmp.
+ int memcmp_result = memcmp(&a1.addr_, &a2.addr_,
+ sizeof(asio::detail::in6_addr_type));
+ if (memcmp_result < 0)
+ return true;
+ if (memcmp_result > 0)
+ return false;
+ return a1.scope_id_ < a2.scope_id_;
+}
+
+address_v6 address_v6::loopback()
+{
+ address_v6 tmp;
+ tmp.addr_.s6_addr[15] = 1;
+ return tmp;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+address_v6 address_v6::v4_mapped(const address_v4& addr)
+{
+ address_v4::bytes_type v4_bytes = addr.to_bytes();
+ bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF,
+ v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
+ return address_v6(v6_bytes);
+}
+
+address_v6 address_v6::v4_compatible(const address_v4& addr)
+{
+ address_v4::bytes_type v4_bytes = addr.to_bytes();
+ bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
+ return address_v6(v6_bytes);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+address_v6 make_address_v6(const char* str)
+{
+ asio::error_code ec;
+ address_v6 addr = make_address_v6(str, ec);
+ asio::detail::throw_error(ec);
+ return addr;
+}
+
+address_v6 make_address_v6(
+ const char* str, asio::error_code& ec)
+{
+ address_v6::bytes_type bytes;
+ unsigned long scope_id = 0;
+ if (asio::detail::socket_ops::inet_pton(
+ ASIO_OS_DEF(AF_INET6), str, &bytes[0], &scope_id, ec) <= 0)
+ return address_v6();
+ return address_v6(bytes, scope_id);
+}
+
+address_v6 make_address_v6(const std::string& str)
+{
+ return make_address_v6(str.c_str());
+}
+
+address_v6 make_address_v6(
+ const std::string& str, asio::error_code& ec)
+{
+ return make_address_v6(str.c_str(), ec);
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+address_v6 make_address_v6(string_view str)
+{
+ return make_address_v6(static_cast<std::string>(str));
+}
+
+address_v6 make_address_v6(string_view str,
+ asio::error_code& ec)
+{
+ return make_address_v6(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+address_v4 make_address_v4(
+ v4_mapped_t, const address_v6& v6_addr)
+{
+ if (!v6_addr.is_v4_mapped())
+ {
+ bad_address_cast ex;
+ asio::detail::throw_exception(ex);
+ }
+
+ address_v6::bytes_type v6_bytes = v6_addr.to_bytes();
+ address_v4::bytes_type v4_bytes = { { v6_bytes[12],
+ v6_bytes[13], v6_bytes[14], v6_bytes[15] } };
+ return address_v4(v4_bytes);
+}
+
+address_v6 make_address_v6(
+ v4_mapped_t, const address_v4& v4_addr)
+{
+ address_v4::bytes_type v4_bytes = v4_addr.to_bytes();
+ address_v6::bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0xFF, 0xFF, v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
+ return address_v6(v6_bytes);
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_ADDRESS_V6_IPP
diff --git a/lib/asio/ip/impl/basic_endpoint.hpp b/lib/asio/ip/impl/basic_endpoint.hpp
new file mode 100644
index 0000000..5680a43
--- /dev/null
+++ b/lib/asio/ip/impl/basic_endpoint.hpp
@@ -0,0 +1,43 @@
+//
+// ip/impl/basic_endpoint.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
+#define ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits, typename InternetProtocol>
+std::basic_ostream<Elem, Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& os,
+ const basic_endpoint<InternetProtocol>& endpoint)
+{
+ asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
+ return os << tmp_ep.to_string().c_str();
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
diff --git a/lib/asio/ip/impl/host_name.ipp b/lib/asio/ip/impl/host_name.ipp
new file mode 100644
index 0000000..932ab1c
--- /dev/null
+++ b/lib/asio/ip/impl/host_name.ipp
@@ -0,0 +1,54 @@
+//
+// ip/impl/host_name.ipp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_HOST_NAME_IPP
+#define ASIO_IP_IMPL_HOST_NAME_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/socket_ops.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/winsock_init.hpp"
+#include "asio/ip/host_name.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+std::string host_name()
+{
+ char name[1024];
+ asio::error_code ec;
+ if (asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
+ {
+ asio::detail::throw_error(ec);
+ return std::string();
+ }
+ return std::string(name);
+}
+
+std::string host_name(asio::error_code& ec)
+{
+ char name[1024];
+ if (asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
+ return std::string();
+ return std::string(name);
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_HOST_NAME_IPP
diff --git a/lib/asio/ip/impl/network_v4.hpp b/lib/asio/ip/impl/network_v4.hpp
new file mode 100644
index 0000000..911a45c
--- /dev/null
+++ b/lib/asio/ip/impl/network_v4.hpp
@@ -0,0 +1,54 @@
+//
+// ip/impl/network_v4.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V4_HPP
+#define ASIO_IP_IMPL_NETWORK_V4_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& os, const network_v4& addr)
+{
+ asio::error_code ec;
+ std::string s = addr.to_string(ec);
+ if (ec)
+ {
+ if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+ asio::detail::throw_error(ec);
+ else
+ os.setstate(std::basic_ostream<Elem, Traits>::failbit);
+ }
+ else
+ for (std::string::iterator i = s.begin(); i != s.end(); ++i)
+ os << os.widen(*i);
+ return os;
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_NETWORK_V4_HPP
diff --git a/lib/asio/ip/impl/network_v4.ipp b/lib/asio/ip/impl/network_v4.ipp
new file mode 100644
index 0000000..4b27887
--- /dev/null
+++ b/lib/asio/ip/impl/network_v4.ipp
@@ -0,0 +1,216 @@
+//
+// ip/impl/network_v4.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V4_IPP
+#define ASIO_IP_IMPL_NETWORK_V4_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <stdexcept>
+#include "asio/error.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/ip/network_v4.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+network_v4::network_v4(const address_v4& addr, unsigned short prefix_len)
+ : address_(addr),
+ prefix_length_(prefix_len)
+{
+ if (prefix_len > 32)
+ {
+ std::out_of_range ex("prefix length too large");
+ asio::detail::throw_exception(ex);
+ }
+}
+
+network_v4::network_v4(const address_v4& addr, const address_v4& mask)
+ : address_(addr),
+ prefix_length_(0)
+{
+ address_v4::bytes_type mask_bytes = mask.to_bytes();
+ bool finished = false;
+ for (std::size_t i = 0; i < mask_bytes.size(); ++i)
+ {
+ if (finished)
+ {
+ if (mask_bytes[i])
+ {
+ std::invalid_argument ex("non-contiguous netmask");
+ asio::detail::throw_exception(ex);
+ }
+ continue;
+ }
+ else
+ {
+ switch (mask_bytes[i])
+ {
+ case 255:
+ prefix_length_ += 8;
+ break;
+ case 254: // prefix_length_ += 7
+ prefix_length_ += 1;
+ case 252: // prefix_length_ += 6
+ prefix_length_ += 1;
+ case 248: // prefix_length_ += 5
+ prefix_length_ += 1;
+ case 240: // prefix_length_ += 4
+ prefix_length_ += 1;
+ case 224: // prefix_length_ += 3
+ prefix_length_ += 1;
+ case 192: // prefix_length_ += 2
+ prefix_length_ += 1;
+ case 128: // prefix_length_ += 1
+ prefix_length_ += 1;
+ case 0: // nbits += 0
+ finished = true;
+ break;
+ default:
+ std::out_of_range ex("non-contiguous netmask");
+ asio::detail::throw_exception(ex);
+ }
+ }
+ }
+}
+
+address_v4 network_v4::netmask() const ASIO_NOEXCEPT
+{
+ uint32_t nmbits = 0xffffffff;
+ if (prefix_length_ == 0)
+ nmbits = 0;
+ else
+ nmbits = nmbits << (32 - prefix_length_);
+ return address_v4(nmbits);
+}
+
+address_v4_range network_v4::hosts() const ASIO_NOEXCEPT
+{
+ return is_host()
+ ? address_v4_range(address_, address_v4(address_.to_uint() + 1))
+ : address_v4_range(address_v4(network().to_uint() + 1), broadcast());
+}
+
+bool network_v4::is_subnet_of(const network_v4& other) const
+{
+ if (other.prefix_length_ >= prefix_length_)
+ return false; // Only real subsets are allowed.
+ const network_v4 me(address_, other.prefix_length_);
+ return other.canonical() == me.canonical();
+}
+
+std::string network_v4::to_string() const
+{
+ asio::error_code ec;
+ std::string addr = to_string(ec);
+ asio::detail::throw_error(ec);
+ return addr;
+}
+
+std::string network_v4::to_string(asio::error_code& ec) const
+{
+ using namespace std; // For sprintf.
+ ec = asio::error_code();
+ char prefix_len[16];
+#if defined(ASIO_HAS_SECURE_RTL)
+ sprintf_s(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
+#else // defined(ASIO_HAS_SECURE_RTL)
+ sprintf(prefix_len, "/%u", prefix_length_);
+#endif // defined(ASIO_HAS_SECURE_RTL)
+ return address_.to_string() + prefix_len;
+}
+
+network_v4 make_network_v4(const char* str)
+{
+ return make_network_v4(std::string(str));
+}
+
+network_v4 make_network_v4(const char* str, asio::error_code& ec)
+{
+ return make_network_v4(std::string(str), ec);
+}
+
+network_v4 make_network_v4(const std::string& str)
+{
+ asio::error_code ec;
+ network_v4 net = make_network_v4(str, ec);
+ asio::detail::throw_error(ec);
+ return net;
+}
+
+network_v4 make_network_v4(const std::string& str,
+ asio::error_code& ec)
+{
+ std::string::size_type pos = str.find_first_of("/");
+
+ if (pos == std::string::npos)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v4();
+ }
+
+ if (pos == str.size() - 1)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v4();
+ }
+
+ std::string::size_type end = str.find_first_not_of("0123456789", pos + 1);
+ if (end != std::string::npos)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v4();
+ }
+
+ const address_v4 addr = make_address_v4(str.substr(0, pos), ec);
+ if (ec)
+ return network_v4();
+
+ const int prefix_len = std::atoi(str.substr(pos + 1).c_str());
+ if (prefix_len < 0 || prefix_len > 32)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v4();
+ }
+
+ return network_v4(addr, static_cast<unsigned short>(prefix_len));
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+network_v4 make_network_v4(string_view str)
+{
+ return make_network_v4(static_cast<std::string>(str));
+}
+
+network_v4 make_network_v4(string_view str,
+ asio::error_code& ec)
+{
+ return make_network_v4(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_NETWORK_V4_IPP
diff --git a/lib/asio/ip/impl/network_v6.hpp b/lib/asio/ip/impl/network_v6.hpp
new file mode 100644
index 0000000..b0eedad
--- /dev/null
+++ b/lib/asio/ip/impl/network_v6.hpp
@@ -0,0 +1,53 @@
+//
+// ip/impl/network_v6.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V6_HPP
+#define ASIO_IP_IMPL_NETWORK_V6_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& os, const network_v6& addr)
+{
+ asio::error_code ec;
+ std::string s = addr.to_string(ec);
+ if (ec)
+ {
+ if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+ asio::detail::throw_error(ec);
+ else
+ os.setstate(std::basic_ostream<Elem, Traits>::failbit);
+ }
+ else
+ for (std::string::iterator i = s.begin(); i != s.end(); ++i)
+ os << os.widen(*i);
+ return os;
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_NETWORK_V6_HPP
diff --git a/lib/asio/ip/impl/network_v6.ipp b/lib/asio/ip/impl/network_v6.ipp
new file mode 100644
index 0000000..2e37a99
--- /dev/null
+++ b/lib/asio/ip/impl/network_v6.ipp
@@ -0,0 +1,185 @@
+//
+// ip/impl/network_v6.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V6_IPP
+#define ASIO_IP_IMPL_NETWORK_V6_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <stdexcept>
+#include "asio/error.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/ip/network_v6.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+network_v6::network_v6(const address_v6& addr, unsigned short prefix_len)
+ : address_(addr),
+ prefix_length_(prefix_len)
+{
+ if (prefix_len > 128)
+ {
+ std::out_of_range ex("prefix length too large");
+ asio::detail::throw_exception(ex);
+ }
+}
+
+ASIO_DECL address_v6 network_v6::network() const ASIO_NOEXCEPT
+{
+ address_v6::bytes_type bytes(address_.to_bytes());
+ for (std::size_t i = 0; i < 16; ++i)
+ {
+ if (prefix_length_ <= i * 8)
+ bytes[i] = 0;
+ else if (prefix_length_ < (i + 1) * 8)
+ bytes[i] &= 0xFF00 >> (prefix_length_ % 8);
+ }
+ return address_v6(bytes, address_.scope_id());
+}
+
+address_v6_range network_v6::hosts() const ASIO_NOEXCEPT
+{
+ address_v6::bytes_type begin_bytes(address_.to_bytes());
+ address_v6::bytes_type end_bytes(address_.to_bytes());
+ for (std::size_t i = 0; i < 16; ++i)
+ {
+ if (prefix_length_ <= i * 8)
+ {
+ begin_bytes[i] = 0;
+ end_bytes[i] = 0xFF;
+ }
+ else if (prefix_length_ < (i + 1) * 8)
+ {
+ begin_bytes[i] &= 0xFF00 >> (prefix_length_ % 8);
+ end_bytes[i] |= 0xFF >> (prefix_length_ % 8);
+ }
+ }
+ return address_v6_range(
+ address_v6_iterator(address_v6(begin_bytes, address_.scope_id())),
+ ++address_v6_iterator(address_v6(end_bytes, address_.scope_id())));
+}
+
+bool network_v6::is_subnet_of(const network_v6& other) const
+{
+ if (other.prefix_length_ >= prefix_length_)
+ return false; // Only real subsets are allowed.
+ const network_v6 me(address_, other.prefix_length_);
+ return other.canonical() == me.canonical();
+}
+
+std::string network_v6::to_string() const
+{
+ asio::error_code ec;
+ std::string addr = to_string(ec);
+ asio::detail::throw_error(ec);
+ return addr;
+}
+
+std::string network_v6::to_string(asio::error_code& ec) const
+{
+ using namespace std; // For sprintf.
+ ec = asio::error_code();
+ char prefix_len[16];
+#if defined(ASIO_HAS_SECURE_RTL)
+ sprintf_s(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
+#else // defined(ASIO_HAS_SECURE_RTL)
+ sprintf(prefix_len, "/%u", prefix_length_);
+#endif // defined(ASIO_HAS_SECURE_RTL)
+ return address_.to_string() + prefix_len;
+}
+
+network_v6 make_network_v6(const char* str)
+{
+ return make_network_v6(std::string(str));
+}
+
+network_v6 make_network_v6(const char* str, asio::error_code& ec)
+{
+ return make_network_v6(std::string(str), ec);
+}
+
+network_v6 make_network_v6(const std::string& str)
+{
+ asio::error_code ec;
+ network_v6 net = make_network_v6(str, ec);
+ asio::detail::throw_error(ec);
+ return net;
+}
+
+network_v6 make_network_v6(const std::string& str,
+ asio::error_code& ec)
+{
+ std::string::size_type pos = str.find_first_of("/");
+
+ if (pos == std::string::npos)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v6();
+ }
+
+ if (pos == str.size() - 1)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v6();
+ }
+
+ std::string::size_type end = str.find_first_not_of("0123456789", pos + 1);
+ if (end != std::string::npos)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v6();
+ }
+
+ const address_v6 addr = make_address_v6(str.substr(0, pos), ec);
+ if (ec)
+ return network_v6();
+
+ const int prefix_len = std::atoi(str.substr(pos + 1).c_str());
+ if (prefix_len < 0 || prefix_len > 128)
+ {
+ ec = asio::error::invalid_argument;
+ return network_v6();
+ }
+
+ return network_v6(addr, static_cast<unsigned short>(prefix_len));
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+network_v6 make_network_v6(string_view str)
+{
+ return make_network_v6(static_cast<std::string>(str));
+}
+
+network_v6 make_network_v6(string_view str,
+ asio::error_code& ec)
+{
+ return make_network_v6(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_NETWORK_V6_IPP
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 16:14:25 +0000