Added boost header

test/external/boost/asio/ip/address.hpp

@@ -0,0 +1,202 @@
+//
+// ip/address.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_ADDRESS_HPP
+#define BOOST_ASIO_IP_ADDRESS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/ip/address_v4.hpp>
+#include <boost/asio/ip/address_v6.hpp>
+
+#if !defined(BOOST_NO_IOSTREAM)
+# include <iosfwd>
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Implements version-independent IP addresses.
+/**
+ * The boost::asio::ip::address class provides the ability to use either IP
+ * version 4 or version 6 addresses.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class address
+{
+public:
+  /// Default constructor.
+  BOOST_ASIO_DECL address();
+
+  /// Construct an address from an IPv4 address.
+  BOOST_ASIO_DECL address(const boost::asio::ip::address_v4& ipv4_address);
+
+  /// Construct an address from an IPv6 address.
+  BOOST_ASIO_DECL address(const boost::asio::ip::address_v6& ipv6_address);
+
+  /// Copy constructor.
+  BOOST_ASIO_DECL address(const address& other);
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move constructor.
+  BOOST_ASIO_DECL address(address&& other);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// Assign from another address.
+  BOOST_ASIO_DECL address& operator=(const address& other);
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move-assign from another address.
+  BOOST_ASIO_DECL address& operator=(address&& other);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// Assign from an IPv4 address.
+  BOOST_ASIO_DECL address& operator=(
+      const boost::asio::ip::address_v4& ipv4_address);
+
+  /// Assign from an IPv6 address.
+  BOOST_ASIO_DECL address& operator=(
+      const boost::asio::ip::address_v6& ipv6_address);
+
+  /// Get whether the address is an IP version 4 address.
+  bool is_v4() const
+  {
+    return type_ == ipv4;
+  }
+
+  /// Get whether the address is an IP version 6 address.
+  bool is_v6() const
+  {
+    return type_ == ipv6;
+  }
+
+  /// Get the address as an IP version 4 address.
+  BOOST_ASIO_DECL boost::asio::ip::address_v4 to_v4() const;
+
+  /// Get the address as an IP version 6 address.
+  BOOST_ASIO_DECL boost::asio::ip::address_v6 to_v6() const;
+
+  /// Get the address as a string in dotted decimal format.
+  BOOST_ASIO_DECL std::string to_string() const;
+
+  /// Get the address as a string in dotted decimal format.
+  BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
+
+  /// Create an address from an IPv4 address string in dotted decimal form,
+  /// or from an IPv6 address in hexadecimal notation.
+  BOOST_ASIO_DECL static address from_string(const char* str);
+
+  /// Create an address from an IPv4 address string in dotted decimal form,
+  /// or from an IPv6 address in hexadecimal notation.
+  BOOST_ASIO_DECL static address from_string(
+      const char* str, boost::system::error_code& ec);
+
+  /// Create an address from an IPv4 address string in dotted decimal form,
+  /// or from an IPv6 address in hexadecimal notation.
+  BOOST_ASIO_DECL static address from_string(const std::string& str);
+
+  /// Create an address from an IPv4 address string in dotted decimal form,
+  /// or from an IPv6 address in hexadecimal notation.
+  BOOST_ASIO_DECL static address from_string(
+      const std::string& str, boost::system::error_code& ec);
+
+  /// Determine whether the address is a loopback address.
+  BOOST_ASIO_DECL bool is_loopback() const;
+
+  /// Determine whether the address is unspecified.
+  BOOST_ASIO_DECL bool is_unspecified() const;
+
+  /// Determine whether the address is a multicast address.
+  BOOST_ASIO_DECL bool is_multicast() const;
+
+  /// Compare two addresses for equality.
+  BOOST_ASIO_DECL friend bool operator==(const address& a1, const address& a2);
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const address& a1, const address& a2)
+  {
+    return !(a1 == a2);
+  }
+
+  /// Compare addresses for ordering.
+  BOOST_ASIO_DECL friend bool operator<(const address& a1, const address& a2);
+
+  /// Compare addresses for ordering.
+  friend bool operator>(const address& a1, const address& a2)
+  {
+    return a2 < a1;
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator<=(const address& a1, const address& a2)
+  {
+    return !(a2 < a1);
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator>=(const address& a1, const address& a2)
+  {
+    return !(a1 < a2);
+  }
+
+private:
+  // The type of the address.
+  enum { ipv4, ipv6 } type_;
+
+  // The underlying IPv4 address.
+  boost::asio::ip::address_v4 ipv4_address_;
+
+  // The underlying IPv6 address.
+  boost::asio::ip::address_v6 ipv6_address_;
+};
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+/// Output an address as a string.
+/**
+ * Used to output a human-readable string for a specified address.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param addr The address to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::address
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address& addr);
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/ip/impl/address.hpp>
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/ip/impl/address.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_IP_ADDRESS_HPP

test/external/boost/asio/ip/address_v4.hpp

@@ -0,0 +1,243 @@
+//
+// ip/address_v4.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_ADDRESS_V4_HPP
+#define BOOST_ASIO_IP_ADDRESS_V4_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+#include <boost/asio/detail/array.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/winsock_init.hpp>
+#include <boost/system/error_code.hpp>
+
+#if !defined(BOOST_NO_IOSTREAM)
+# include <iosfwd>
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Implements IP version 4 style addresses.
+/**
+ * The boost::asio::ip::address_v4 class provides the ability to use and
+ * manipulate IP version 4 addresses.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class address_v4
+{
+public:
+  /// The type used to represent an address as an array of bytes.
+  /**
+   * @note This type is defined in terms of the C++0x template @c std::array
+   * when it is available. Otherwise, it uses @c boost:array.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef array<unsigned char, 4> bytes_type;
+#else
+  typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
+#endif
+
+  /// Default constructor.
+  address_v4()
+  {
+    addr_.s_addr = 0;
+  }
+
+  /// Construct an address from raw bytes.
+  BOOST_ASIO_DECL explicit address_v4(const bytes_type& bytes);
+
+  /// Construct an address from a unsigned long in host byte order.
+  BOOST_ASIO_DECL explicit address_v4(unsigned long addr);
+
+  /// Copy constructor.
+  address_v4(const address_v4& other)
+    : addr_(other.addr_)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move constructor.
+  address_v4(address_v4&& other)
+    : addr_(other.addr_)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// Assign from another address.
+  address_v4& operator=(const address_v4& other)
+  {
+    addr_ = other.addr_;
+    return *this;
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move-assign from another address.
+  address_v4& operator=(address_v4&& other)
+  {
+    addr_ = other.addr_;
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// Get the address in bytes, in network byte order.
+  BOOST_ASIO_DECL bytes_type to_bytes() const;
+
+  /// Get the address as an unsigned long in host byte order
+  BOOST_ASIO_DECL unsigned long to_ulong() const;
+
+  /// Get the address as a string in dotted decimal format.
+  BOOST_ASIO_DECL std::string to_string() const;
+
+  /// Get the address as a string in dotted decimal format.
+  BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
+
+  /// Create an address from an IP address string in dotted decimal form.
+  BOOST_ASIO_DECL static address_v4 from_string(const char* str);
+
+  /// Create an address from an IP address string in dotted decimal form.
+  BOOST_ASIO_DECL static address_v4 from_string(
+      const char* str, boost::system::error_code& ec);
+
+  /// Create an address from an IP address string in dotted decimal form.
+  BOOST_ASIO_DECL static address_v4 from_string(const std::string& str);
+
+  /// Create an address from an IP address string in dotted decimal form.
+  BOOST_ASIO_DECL static address_v4 from_string(
+      const std::string& str, boost::system::error_code& ec);
+
+  /// Determine whether the address is a loopback address.
+  BOOST_ASIO_DECL bool is_loopback() const;
+
+  /// Determine whether the address is unspecified.
+  BOOST_ASIO_DECL bool is_unspecified() const;
+
+  /// Determine whether the address is a class A address.
+  BOOST_ASIO_DECL bool is_class_a() const;
+
+  /// Determine whether the address is a class B address.
+  BOOST_ASIO_DECL bool is_class_b() const;
+
+  /// Determine whether the address is a class C address.
+  BOOST_ASIO_DECL bool is_class_c() const;
+
+  /// Determine whether the address is a multicast address.
+  BOOST_ASIO_DECL bool is_multicast() const;
+
+  /// Compare two addresses for equality.
+  friend bool operator==(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.addr_.s_addr == a2.addr_.s_addr;
+  }
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.addr_.s_addr != a2.addr_.s_addr;
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator<(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.to_ulong() < a2.to_ulong();
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator>(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.to_ulong() > a2.to_ulong();
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator<=(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.to_ulong() <= a2.to_ulong();
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator>=(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.to_ulong() >= a2.to_ulong();
+  }
+
+  /// Obtain an address object that represents any address.
+  static address_v4 any()
+  {
+    return address_v4();
+  }
+
+  /// Obtain an address object that represents the loopback address.
+  static address_v4 loopback()
+  {
+    return address_v4(0x7F000001);
+  }
+
+  /// Obtain an address object that represents the broadcast address.
+  static address_v4 broadcast()
+  {
+    return address_v4(0xFFFFFFFF);
+  }
+
+  /// Obtain an address object that represents the broadcast address that
+  /// corresponds to the specified address and netmask.
+  BOOST_ASIO_DECL static address_v4 broadcast(
+      const address_v4& addr, const address_v4& mask);
+
+  /// Obtain the netmask that corresponds to the address, based on its address
+  /// class.
+  BOOST_ASIO_DECL static address_v4 netmask(const address_v4& addr);
+
+private:
+  // The underlying IPv4 address.
+  boost::asio::detail::in4_addr_type addr_;
+};
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+/// Output an address as a string.
+/**
+ * Used to output a human-readable string for a specified address.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param addr The address to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::address_v4
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/ip/impl/address_v4.hpp>
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/ip/impl/address_v4.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_IP_ADDRESS_V4_HPP

test/external/boost/asio/ip/address_v6.hpp

@@ -0,0 +1,248 @@
+//
+// ip/address_v6.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_ADDRESS_V6_HPP
+#define BOOST_ASIO_IP_ADDRESS_V6_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+#include <boost/asio/detail/array.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/winsock_init.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/ip/address_v4.hpp>
+
+#if !defined(BOOST_NO_IOSTREAM)
+# include <iosfwd>
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Implements IP version 6 style addresses.
+/**
+ * The boost::asio::ip::address_v6 class provides the ability to use and
+ * manipulate IP version 6 addresses.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class address_v6
+{
+public:
+  /// The type used to represent an address as an array of bytes.
+  /**
+   * @note This type is defined in terms of the C++0x template @c std::array
+   * when it is available. Otherwise, it uses @c boost:array.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef array<unsigned char, 16> bytes_type;
+#else
+  typedef boost::asio::detail::array<unsigned char, 16> bytes_type;
+#endif
+
+  /// Default constructor.
+  BOOST_ASIO_DECL address_v6();
+
+  /// Construct an address from raw bytes and scope ID.
+  BOOST_ASIO_DECL explicit address_v6(const bytes_type& bytes,
+      unsigned long scope_id = 0);
+
+  /// Copy constructor.
+  BOOST_ASIO_DECL address_v6(const address_v6& other);
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move constructor.
+  BOOST_ASIO_DECL address_v6(address_v6&& other);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// Assign from another address.
+  BOOST_ASIO_DECL address_v6& operator=(const address_v6& other);
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move-assign from another address.
+  BOOST_ASIO_DECL address_v6& operator=(address_v6&& other);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// The scope ID of the address.
+  /**
+   * Returns the scope ID associated with the IPv6 address.
+   */
+  unsigned long scope_id() const
+  {
+    return scope_id_;
+  }
+
+  /// The scope ID of the address.
+  /**
+   * Modifies the scope ID associated with the IPv6 address.
+   */
+  void scope_id(unsigned long id)
+  {
+    scope_id_ = id;
+  }
+
+  /// Get the address in bytes, in network byte order.
+  BOOST_ASIO_DECL bytes_type to_bytes() const;
+
+  /// Get the address as a string.
+  BOOST_ASIO_DECL std::string to_string() const;
+
+  /// Get the address as a string.
+  BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
+
+  /// Create an address from an IP address string.
+  BOOST_ASIO_DECL static address_v6 from_string(const char* str);
+
+  /// Create an address from an IP address string.
+  BOOST_ASIO_DECL static address_v6 from_string(
+      const char* str, boost::system::error_code& ec);
+
+  /// Create an address from an IP address string.
+  BOOST_ASIO_DECL static address_v6 from_string(const std::string& str);
+
+  /// Create an address from an IP address string.
+  BOOST_ASIO_DECL static address_v6 from_string(
+      const std::string& str, boost::system::error_code& ec);
+
+  /// Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address.
+  BOOST_ASIO_DECL address_v4 to_v4() const;
+
+  /// Determine whether the address is a loopback address.
+  BOOST_ASIO_DECL bool is_loopback() const;
+
+  /// Determine whether the address is unspecified.
+  BOOST_ASIO_DECL bool is_unspecified() const;
+
+  /// Determine whether the address is link local.
+  BOOST_ASIO_DECL bool is_link_local() const;
+
+  /// Determine whether the address is site local.
+  BOOST_ASIO_DECL bool is_site_local() const;
+
+  /// Determine whether the address is a mapped IPv4 address.
+  BOOST_ASIO_DECL bool is_v4_mapped() const;
+
+  /// Determine whether the address is an IPv4-compatible address.
+  BOOST_ASIO_DECL bool is_v4_compatible() const;
+
+  /// Determine whether the address is a multicast address.
+  BOOST_ASIO_DECL bool is_multicast() const;
+
+  /// Determine whether the address is a global multicast address.
+  BOOST_ASIO_DECL bool is_multicast_global() const;
+
+  /// Determine whether the address is a link-local multicast address.
+  BOOST_ASIO_DECL bool is_multicast_link_local() const;
+
+  /// Determine whether the address is a node-local multicast address.
+  BOOST_ASIO_DECL bool is_multicast_node_local() const;
+
+  /// Determine whether the address is a org-local multicast address.
+  BOOST_ASIO_DECL bool is_multicast_org_local() const;
+
+  /// Determine whether the address is a site-local multicast address.
+  BOOST_ASIO_DECL bool is_multicast_site_local() const;
+
+  /// Compare two addresses for equality.
+  BOOST_ASIO_DECL friend bool operator==(
+      const address_v6& a1, const address_v6& a2);
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const address_v6& a1, const address_v6& a2)
+  {
+    return !(a1 == a2);
+  }
+
+  /// Compare addresses for ordering.
+  BOOST_ASIO_DECL friend bool operator<(
+      const address_v6& a1, const address_v6& a2);
+
+  /// Compare addresses for ordering.
+  friend bool operator>(const address_v6& a1, const address_v6& a2)
+  {
+    return a2 < a1;
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator<=(const address_v6& a1, const address_v6& a2)
+  {
+    return !(a2 < a1);
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator>=(const address_v6& a1, const address_v6& a2)
+  {
+    return !(a1 < a2);
+  }
+
+  /// Obtain an address object that represents any address.
+  static address_v6 any()
+  {
+    return address_v6();
+  }
+
+  /// Obtain an address object that represents the loopback address.
+  BOOST_ASIO_DECL static address_v6 loopback();
+
+  /// Create an IPv4-mapped IPv6 address.
+  BOOST_ASIO_DECL static address_v6 v4_mapped(const address_v4& addr);
+
+  /// Create an IPv4-compatible IPv6 address.
+  BOOST_ASIO_DECL static address_v6 v4_compatible(const address_v4& addr);
+
+private:
+  // The underlying IPv6 address.
+  boost::asio::detail::in6_addr_type addr_;
+
+  // The scope ID associated with the address.
+  unsigned long scope_id_;
+};
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+/// Output an address as a string.
+/**
+ * Used to output a human-readable string for a specified address.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param addr The address to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::address_v6
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/ip/impl/address_v6.hpp>
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/ip/impl/address_v6.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_IP_ADDRESS_V6_HPP

test/external/boost/asio/ip/basic_endpoint.hpp

@@ -0,0 +1,265 @@
+//
+// ip/basic_endpoint.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
+#define BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/ip/address.hpp>
+#include <boost/asio/ip/detail/endpoint.hpp>
+
+#if !defined(BOOST_NO_IOSTREAM)
+# include <iosfwd>
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Describes an endpoint for a version-independent IP socket.
+/**
+ * The boost::asio::ip::basic_endpoint class template describes an endpoint that
+ * may be associated with a particular socket.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Endpoint.
+ */
+template <typename InternetProtocol>
+class basic_endpoint
+{
+public:
+  /// The protocol type associated with the endpoint.
+  typedef InternetProtocol protocol_type;
+
+  /// The type of the endpoint structure. This type is dependent on the
+  /// underlying implementation of the socket layer.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined data_type;
+#else
+  typedef boost::asio::detail::socket_addr_type data_type;
+#endif
+
+  /// Default constructor.
+  basic_endpoint()
+    : impl_()
+  {
+  }
+
+  /// Construct an endpoint using a port number, specified in the host's byte
+  /// order. The IP address will be the any address (i.e. INADDR_ANY or
+  /// in6addr_any). This constructor would typically be used for accepting new
+  /// connections.
+  /**
+   * @par Examples
+   * To initialise an IPv4 TCP endpoint for port 1234, use:
+   * @code
+   * boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), 1234);
+   * @endcode
+   *
+   * To specify an IPv6 UDP endpoint for port 9876, use:
+   * @code
+   * boost::asio::ip::udp::endpoint ep(boost::asio::ip::udp::v6(), 9876);
+   * @endcode
+   */
+  basic_endpoint(const InternetProtocol& internet_protocol,
+      unsigned short port_num)
+    : impl_(internet_protocol.family(), port_num)
+  {
+  }
+
+  /// Construct an endpoint using a port number and an IP address. This
+  /// constructor may be used for accepting connections on a specific interface
+  /// or for making a connection to a remote endpoint.
+  basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
+    : impl_(addr, port_num)
+  {
+  }
+
+  /// Copy constructor.
+  basic_endpoint(const basic_endpoint& other)
+    : impl_(other.impl_)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move constructor.
+  basic_endpoint(basic_endpoint&& other)
+    : impl_(other.impl_)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// Assign from another endpoint.
+  basic_endpoint& operator=(const basic_endpoint& other)
+  {
+    impl_ = other.impl_;
+    return *this;
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move-assign from another endpoint.
+  basic_endpoint& operator=(basic_endpoint&& other)
+  {
+    impl_ = other.impl_;
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// The protocol associated with the endpoint.
+  protocol_type protocol() const
+  {
+    if (impl_.is_v4())
+      return InternetProtocol::v4();
+    return InternetProtocol::v6();
+  }
+
+  /// Get the underlying endpoint in the native type.
+  data_type* data()
+  {
+    return impl_.data();
+  }
+
+  /// Get the underlying endpoint in the native type.
+  const data_type* data() const
+  {
+    return impl_.data();
+  }
+
+  /// Get the underlying size of the endpoint in the native type.
+  std::size_t size() const
+  {
+    return impl_.size();
+  }
+
+  /// Set the underlying size of the endpoint in the native type.
+  void resize(std::size_t new_size)
+  {
+    impl_.resize(new_size);
+  }
+
+  /// Get the capacity of the endpoint in the native type.
+  std::size_t capacity() const
+  {
+    return impl_.capacity();
+  }
+
+  /// Get the port associated with the endpoint. The port number is always in
+  /// the host's byte order.
+  unsigned short port() const
+  {
+    return impl_.port();
+  }
+
+  /// Set the port associated with the endpoint. The port number is always in
+  /// the host's byte order.
+  void port(unsigned short port_num)
+  {
+    impl_.port(port_num);
+  }
+
+  /// Get the IP address associated with the endpoint.
+  boost::asio::ip::address address() const
+  {
+    return impl_.address();
+  }
+
+  /// Set the IP address associated with the endpoint.
+  void address(const boost::asio::ip::address& addr)
+  {
+    impl_.address(addr);
+  }
+
+  /// Compare two endpoints for equality.
+  friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
+      const basic_endpoint<InternetProtocol>& e2)
+  {
+    return e1.impl_ == e2.impl_;
+  }
+
+  /// Compare two endpoints for inequality.
+  friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
+      const basic_endpoint<InternetProtocol>& e2)
+  {
+    return !(e1 == e2);
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
+      const basic_endpoint<InternetProtocol>& e2)
+  {
+    return e1.impl_ < e2.impl_;
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
+      const basic_endpoint<InternetProtocol>& e2)
+  {
+    return e2.impl_ < e1.impl_;
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
+      const basic_endpoint<InternetProtocol>& e2)
+  {
+    return !(e2 < e1);
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
+      const basic_endpoint<InternetProtocol>& e2)
+  {
+    return !(e1 < e2);
+  }
+
+private:
+  // The underlying IP endpoint.
+  boost::asio::ip::detail::endpoint impl_;
+};
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+/// Output an endpoint as a string.
+/**
+ * Used to output a human-readable string for a specified endpoint.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param endpoint The endpoint to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::basic_endpoint
+ */
+template <typename Elem, typename Traits, typename InternetProtocol>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os,
+    const basic_endpoint<InternetProtocol>& endpoint);
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/ip/impl/basic_endpoint.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_ENDPOINT_HPP

test/external/boost/asio/ip/basic_resolver.hpp

@@ -0,0 +1,266 @@
+//
+// ip/basic_resolver.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_BASIC_RESOLVER_HPP
+#define BOOST_ASIO_IP_BASIC_RESOLVER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/ip/resolver_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Provides endpoint resolution functionality.
+/**
+ * The basic_resolver class template provides the ability to resolve a query
+ * to a list of endpoints.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename InternetProtocol,
+    typename ResolverService = resolver_service<InternetProtocol> >
+class basic_resolver
+  : public basic_io_object<ResolverService>
+{
+public:
+  /// The protocol type.
+  typedef InternetProtocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename InternetProtocol::endpoint endpoint_type;
+
+  /// The query type.
+  typedef basic_resolver_query<InternetProtocol> query;
+
+  /// The iterator type.
+  typedef basic_resolver_iterator<InternetProtocol> iterator;
+
+  /// Constructor.
+  /**
+   * This constructor creates a basic_resolver.
+   *
+   * @param io_service The io_service object that the resolver will use to
+   * dispatch handlers for any asynchronous operations performed on the timer.
+   */
+  explicit basic_resolver(boost::asio::io_service& io_service)
+    : basic_io_object<ResolverService>(io_service)
+  {
+  }
+
+  /// Cancel any asynchronous operations that are waiting on the resolver.
+  /**
+   * This function forces the completion of any pending asynchronous
+   * operations on the host resolver. The handler for each cancelled operation
+   * will be invoked with the boost::asio::error::operation_aborted error code.
+   */
+  void cancel()
+  {
+    return this->service.cancel(this->implementation);
+  }
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve a query into a list of endpoint entries.
+   *
+   * @param q A query object that determines what endpoints will be returned.
+   *
+   * @returns A forward-only iterator that can be used to traverse the list
+   * of endpoint entries.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * A successful call to this function is guaranteed to return at least one
+   * entry.
+   */
+  iterator resolve(const query& q)
+  {
+    boost::system::error_code ec;
+    iterator i = this->service.resolve(this->implementation, q, ec);
+    boost::asio::detail::throw_error(ec, "resolve");
+    return i;
+  }
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve a query into a list of endpoint entries.
+   *
+   * @param q A query object that determines what endpoints will be returned.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns A forward-only iterator that can be used to traverse the list
+   * of endpoint entries. Returns a default constructed iterator if an error
+   * occurs.
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * A successful call to this function is guaranteed to return at least one
+   * entry.
+   */
+  iterator resolve(const query& q, boost::system::error_code& ec)
+  {
+    return this->service.resolve(this->implementation, q, ec);
+  }
+
+  /// Asynchronously perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to asynchronously resolve a query into a list of
+   * endpoint entries.
+   *
+   * @param q A query object that determines what endpoints will be returned.
+   *
+   * @param handler The handler to be called when the resolve operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   resolver::iterator iterator             // Forward-only iterator that can
+   *                                           // be used to traverse the list
+   *                                           // of endpoint entries.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * A successful resolve operation is guaranteed to pass at least one entry to
+   * the handler.
+   */
+  template <typename ResolveHandler>
+  void async_resolve(const query& q,
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ResolveHandler.
+    BOOST_ASIO_RESOLVE_HANDLER_CHECK(
+        ResolveHandler, handler, iterator) type_check;
+
+    return this->service.async_resolve(this->implementation, q,
+        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+  }
+
+  /// Perform reverse resolution of an endpoint to a list of entries.
+  /**
+   * This function is used to resolve an endpoint into a list of endpoint
+   * entries.
+   *
+   * @param e An endpoint object that determines what endpoints will be
+   * returned.
+   *
+   * @returns A forward-only iterator that can be used to traverse the list
+   * of endpoint entries.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * A successful call to this function is guaranteed to return at least one
+   * entry.
+   */
+  iterator resolve(const endpoint_type& e)
+  {
+    boost::system::error_code ec;
+    iterator i = this->service.resolve(this->implementation, e, ec);
+    boost::asio::detail::throw_error(ec, "resolve");
+    return i;
+  }
+
+  /// Perform reverse resolution of an endpoint to a list of entries.
+  /**
+   * This function is used to resolve an endpoint into a list of endpoint
+   * entries.
+   *
+   * @param e An endpoint object that determines what endpoints will be
+   * returned.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns A forward-only iterator that can be used to traverse the list
+   * of endpoint entries. Returns a default constructed iterator if an error
+   * occurs.
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * A successful call to this function is guaranteed to return at least one
+   * entry.
+   */
+  iterator resolve(const endpoint_type& e, boost::system::error_code& ec)
+  {
+    return this->service.resolve(this->implementation, e, ec);
+  }
+
+  /// Asynchronously perform reverse resolution of an endpoint to a list of
+  /// entries.
+  /**
+   * This function is used to asynchronously resolve an endpoint into a list of
+   * endpoint entries.
+   *
+   * @param e An endpoint object that determines what endpoints will be
+   * returned.
+   *
+   * @param handler The handler to be called when the resolve operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   resolver::iterator iterator             // Forward-only iterator that can
+   *                                           // be used to traverse the list
+   *                                           // of endpoint entries.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * A successful resolve operation is guaranteed to pass at least one entry to
+   * the handler.
+   */
+  template <typename ResolveHandler>
+  void async_resolve(const endpoint_type& e,
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ResolveHandler.
+    BOOST_ASIO_RESOLVE_HANDLER_CHECK(
+        ResolveHandler, handler, iterator) type_check;
+
+    return this->service.async_resolve(this->implementation, e,
+        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+  }
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_RESOLVER_HPP

test/external/boost/asio/ip/basic_resolver_entry.hpp

@@ -0,0 +1,96 @@
+//
+// ip/basic_resolver_entry.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
+#define BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// An entry produced by a resolver.
+/**
+ * The boost::asio::ip::basic_resolver_entry class template describes an entry
+ * as returned by a resolver.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename InternetProtocol>
+class basic_resolver_entry
+{
+public:
+  /// The protocol type associated with the endpoint entry.
+  typedef InternetProtocol protocol_type;
+
+  /// The endpoint type associated with the endpoint entry.
+  typedef typename InternetProtocol::endpoint endpoint_type;
+
+  /// Default constructor.
+  basic_resolver_entry()
+  {
+  }
+
+  /// Construct with specified endpoint, host name and service name.
+  basic_resolver_entry(const endpoint_type& ep,
+      const std::string& host, const std::string& service)
+    : endpoint_(ep),
+      host_name_(host),
+      service_name_(service)
+  {
+  }
+
+  /// Get the endpoint associated with the entry.
+  endpoint_type endpoint() const
+  {
+    return endpoint_;
+  }
+
+  /// Convert to the endpoint associated with the entry.
+  operator endpoint_type() const
+  {
+    return endpoint_;
+  }
+
+  /// Get the host name associated with the entry.
+  std::string host_name() const
+  {
+    return host_name_;
+  }
+
+  /// Get the service name associated with the entry.
+  std::string service_name() const
+  {
+    return service_name_;
+  }
+
+private:
+  endpoint_type endpoint_;
+  std::string host_name_;
+  std::string service_name_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP

test/external/boost/asio/ip/basic_resolver_iterator.hpp

@@ -0,0 +1,197 @@
+//
+// ip/basic_resolver_iterator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
+#define BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
+#include <string>
+#include <vector>
+#include <boost/asio/detail/shared_ptr.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/ip/basic_resolver_entry.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// An iterator over the entries produced by a resolver.
+/**
+ * The boost::asio::ip::basic_resolver_iterator class template is used to define
+ * iterators over the results returned by a resolver.
+ *
+ * The iterator's value_type, obtained when the iterator is dereferenced, is:
+ * @code const basic_resolver_entry<InternetProtocol> @endcode
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename InternetProtocol>
+class basic_resolver_iterator
+{
+public:
+  /// The type used for the distance between two iterators.
+  typedef std::ptrdiff_t difference_type;
+
+  /// The type of the value pointed to by the iterator.
+  typedef basic_resolver_entry<InternetProtocol> value_type;
+
+  /// The type of the result of applying operator->() to the iterator.
+  typedef const basic_resolver_entry<InternetProtocol>* pointer;
+
+  /// The type of the result of applying operator*() to the iterator.
+  typedef const basic_resolver_entry<InternetProtocol>& reference;
+
+  /// The iterator category.
+  typedef std::forward_iterator_tag iterator_category;
+
+  /// Default constructor creates an end iterator.
+  basic_resolver_iterator()
+    : index_(0)
+  {
+  }
+
+  /// Create an iterator from an addrinfo list returned by getaddrinfo.
+  static basic_resolver_iterator create(
+      boost::asio::detail::addrinfo_type* address_info,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_iterator iter;
+    if (!address_info)
+      return iter;
+
+    std::string actual_host_name = host_name;
+    if (address_info->ai_canonname)
+      actual_host_name = address_info->ai_canonname;
+
+    iter.values_.reset(new values_type);
+
+    while (address_info)
+    {
+      if (address_info->ai_family == PF_INET
+          || address_info->ai_family == PF_INET6)
+      {
+        using namespace std; // For memcpy.
+        typename InternetProtocol::endpoint endpoint;
+        endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
+        memcpy(endpoint.data(), address_info->ai_addr,
+            address_info->ai_addrlen);
+        iter.values_->push_back(
+            basic_resolver_entry<InternetProtocol>(endpoint,
+              actual_host_name, service_name));
+      }
+      address_info = address_info->ai_next;
+    }
+
+    return iter;
+  }
+
+  /// Create an iterator from an endpoint, host name and service name.
+  static basic_resolver_iterator create(
+      const typename InternetProtocol::endpoint& endpoint,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_iterator iter;
+    iter.values_.reset(new values_type);
+    iter.values_->push_back(
+        basic_resolver_entry<InternetProtocol>(
+          endpoint, host_name, service_name));
+    return iter;
+  }
+
+  /// Dereference an iterator.
+  const basic_resolver_entry<InternetProtocol>& operator*() const
+  {
+    return dereference();
+  }
+
+  /// Dereference an iterator.
+  const basic_resolver_entry<InternetProtocol>* operator->() const
+  {
+    return &dereference();
+  }
+
+  /// Increment operator (prefix).
+  basic_resolver_iterator& operator++()
+  {
+    increment();
+    return *this;
+  }
+
+  /// Increment operator (postfix).
+  basic_resolver_iterator operator++(int)
+  {
+    basic_resolver_iterator tmp(*this);
+    ++*this;
+    return tmp;
+  }
+
+  /// Test two iterators for equality.
+  friend bool operator==(const basic_resolver_iterator& a,
+      const basic_resolver_iterator& b)
+  {
+    return a.equal(b);
+  }
+
+  /// Test two iterators for inequality.
+  friend bool operator!=(const basic_resolver_iterator& a,
+      const basic_resolver_iterator& b)
+  {
+    return !a.equal(b);
+  }
+
+private:
+  void increment()
+  {
+    if (++index_ == values_->size())
+    {
+      // Reset state to match a default constructed end iterator.
+      values_.reset();
+      index_ = 0;
+    }
+  }
+
+  bool equal(const basic_resolver_iterator& other) const
+  {
+    if (!values_ && !other.values_)
+      return true;
+    if (values_ != other.values_)
+      return false;
+    return index_ == other.index_;
+  }
+
+  const basic_resolver_entry<InternetProtocol>& dereference() const
+  {
+    return (*values_)[index_];
+  }
+
+  typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
+  boost::asio::detail::shared_ptr<values_type> values_;
+  std::size_t index_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP

test/external/boost/asio/ip/basic_resolver_query.hpp

@@ -0,0 +1,246 @@
+//
+// ip/basic_resolver_query.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
+#define BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/ip/resolver_query_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// An query to be passed to a resolver.
+/**
+ * The boost::asio::ip::basic_resolver_query class template describes a query
+ * that can be passed to a resolver.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename InternetProtocol>
+class basic_resolver_query
+  : public resolver_query_base
+{
+public:
+  /// The protocol type associated with the endpoint query.
+  typedef InternetProtocol protocol_type;
+
+  /// Construct with specified service name for any protocol.
+  /**
+   * This constructor is typically used to perform name resolution for local
+   * service binding.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for local service
+   * binding.
+   *
+   * @note On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  basic_resolver_query(const std::string& service,
+      resolver_query_base::flags resolve_flags = passive | address_configured)
+    : hints_(),
+      host_name_(),
+      service_name_(service)
+  {
+    typename InternetProtocol::endpoint endpoint;
+    hints_.ai_flags = static_cast<int>(resolve_flags);
+    hints_.ai_family = PF_UNSPEC;
+    hints_.ai_socktype = endpoint.protocol().type();
+    hints_.ai_protocol = endpoint.protocol().protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Construct with specified service name for a given protocol.
+  /**
+   * This constructor is typically used to perform name resolution for local
+   * service binding with a specific protocol version.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for local service
+   * binding.
+   *
+   * @note On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  basic_resolver_query(const protocol_type& protocol,
+      const std::string& service,
+      resolver_query_base::flags resolve_flags = passive | address_configured)
+    : hints_(),
+      host_name_(),
+      service_name_(service)
+  {
+    hints_.ai_flags = static_cast<int>(resolve_flags);
+    hints_.ai_family = protocol.family();
+    hints_.ai_socktype = protocol.type();
+    hints_.ai_protocol = protocol.protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Construct with specified host name and service name for any protocol.
+  /**
+   * This constructor is typically used to perform name resolution for
+   * communication with remote hosts.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  basic_resolver_query(const std::string& host, const std::string& service,
+      resolver_query_base::flags resolve_flags = address_configured)
+    : hints_(),
+      host_name_(host),
+      service_name_(service)
+  {
+    typename InternetProtocol::endpoint endpoint;
+    hints_.ai_flags = static_cast<int>(resolve_flags);
+    hints_.ai_family = PF_UNSPEC;
+    hints_.ai_socktype = endpoint.protocol().type();
+    hints_.ai_protocol = endpoint.protocol().protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Construct with specified host name and service name for a given protocol.
+  /**
+   * This constructor is typically used to perform name resolution for
+   * communication with remote hosts.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  basic_resolver_query(const protocol_type& protocol,
+      const std::string& host, const std::string& service,
+      resolver_query_base::flags resolve_flags = address_configured)
+    : hints_(),
+      host_name_(host),
+      service_name_(service)
+  {
+    hints_.ai_flags = static_cast<int>(resolve_flags);
+    hints_.ai_family = protocol.family();
+    hints_.ai_socktype = protocol.type();
+    hints_.ai_protocol = protocol.protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Get the hints associated with the query.
+  const boost::asio::detail::addrinfo_type& hints() const
+  {
+    return hints_;
+  }
+
+  /// Get the host name associated with the query.
+  std::string host_name() const
+  {
+    return host_name_;
+  }
+
+  /// Get the service name associated with the query.
+  std::string service_name() const
+  {
+    return service_name_;
+  }
+
+private:
+  boost::asio::detail::addrinfo_type hints_;
+  std::string host_name_;
+  std::string service_name_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP

test/external/boost/asio/ip/detail/endpoint.hpp

@@ -0,0 +1,141 @@
+//
+// ip/detail/endpoint.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP
+#define BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/winsock_init.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/ip/address.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+namespace detail {
+
+// Helper class for implementating an IP endpoint.
+class endpoint
+{
+public:
+  // Default constructor.
+  BOOST_ASIO_DECL endpoint();
+
+  // Construct an endpoint using a family and port number.
+  BOOST_ASIO_DECL endpoint(int family, unsigned short port_num);
+
+  // Construct an endpoint using an address and port number.
+  BOOST_ASIO_DECL endpoint(const boost::asio::ip::address& addr,
+      unsigned short port_num);
+
+  // Copy constructor.
+  endpoint(const endpoint& other)
+    : data_(other.data_)
+  {
+  }
+
+  // Assign from another endpoint.
+  endpoint& operator=(const endpoint& other)
+  {
+    data_ = other.data_;
+    return *this;
+  }
+
+  // Get the underlying endpoint in the native type.
+  boost::asio::detail::socket_addr_type* data()
+  {
+    return &data_.base;
+  }
+
+  // Get the underlying endpoint in the native type.
+  const boost::asio::detail::socket_addr_type* data() const
+  {
+    return &data_.base;
+  }
+
+  // Get the underlying size of the endpoint in the native type.
+  std::size_t size() const
+  {
+    if (is_v4())
+      return sizeof(boost::asio::detail::sockaddr_in4_type);
+    else
+      return sizeof(boost::asio::detail::sockaddr_in6_type);
+  }
+
+  // Set the underlying size of the endpoint in the native type.
+  BOOST_ASIO_DECL void resize(std::size_t new_size);
+
+  // Get the capacity of the endpoint in the native type.
+  std::size_t capacity() const
+  {
+    return sizeof(data_);
+  }
+
+  // Get the port associated with the endpoint.
+  BOOST_ASIO_DECL unsigned short port() const;
+
+  // Set the port associated with the endpoint.
+  BOOST_ASIO_DECL void port(unsigned short port_num);
+
+  // Get the IP address associated with the endpoint.
+  BOOST_ASIO_DECL boost::asio::ip::address address() const;
+
+  // Set the IP address associated with the endpoint.
+  BOOST_ASIO_DECL void address(const boost::asio::ip::address& addr);
+
+  // Compare two endpoints for equality.
+  BOOST_ASIO_DECL friend bool operator==(
+      const endpoint& e1, const endpoint& e2);
+
+  // Compare endpoints for ordering.
+  BOOST_ASIO_DECL friend bool operator<(
+      const endpoint& e1, const endpoint& e2);
+
+  // Determine whether the endpoint is IPv4.
+  bool is_v4() const
+  {
+    return data_.base.sa_family == AF_INET;
+  }
+
+#if !defined(BOOST_NO_IOSTREAM)
+  // Convert to a string.
+  BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+private:
+  // The underlying IP socket address.
+  union data_union
+  {
+    boost::asio::detail::socket_addr_type base;
+    boost::asio::detail::sockaddr_in4_type v4;
+    boost::asio::detail::sockaddr_in6_type v6;
+  } data_;
+};
+
+} // namespace detail
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/ip/detail/impl/endpoint.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP

test/external/boost/asio/ip/detail/impl/endpoint.ipp

@@ -0,0 +1,203 @@
+//
+// ip/detail/impl/endpoint.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
+#define BOOST_ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cstring>
+#if !defined(BOOST_NO_IOSTREAM)
+# include <sstream>
+#endif // !defined(BOOST_NO_IOSTREAM)
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/ip/detail/endpoint.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+namespace detail {
+
+endpoint::endpoint()
+  : data_()
+{
+  data_.v4.sin_family = AF_INET;
+  data_.v4.sin_port = 0;
+  data_.v4.sin_addr.s_addr = INADDR_ANY;
+}
+
+endpoint::endpoint(int family, unsigned short port_num)
+  : data_()
+{
+  using namespace std; // For memcpy.
+  if (family == PF_INET)
+  {
+    data_.v4.sin_family = AF_INET;
+    data_.v4.sin_port =
+      boost::asio::detail::socket_ops::host_to_network_short(port_num);
+    data_.v4.sin_addr.s_addr = INADDR_ANY;
+  }
+  else
+  {
+    data_.v6.sin6_family = AF_INET6;
+    data_.v6.sin6_port =
+      boost::asio::detail::socket_ops::host_to_network_short(port_num);
+    data_.v6.sin6_flowinfo = 0;
+    data_.v6.sin6_addr.s6_addr[0] = 0; data_.v6.sin6_addr.s6_addr[1] = 0;
+    data_.v6.sin6_addr.s6_addr[2] = 0, data_.v6.sin6_addr.s6_addr[3] = 0;
+    data_.v6.sin6_addr.s6_addr[4] = 0, data_.v6.sin6_addr.s6_addr[5] = 0;
+    data_.v6.sin6_addr.s6_addr[6] = 0, data_.v6.sin6_addr.s6_addr[7] = 0;
+    data_.v6.sin6_addr.s6_addr[8] = 0, data_.v6.sin6_addr.s6_addr[9] = 0;
+    data_.v6.sin6_addr.s6_addr[10] = 0, data_.v6.sin6_addr.s6_addr[11] = 0;
+    data_.v6.sin6_addr.s6_addr[12] = 0, data_.v6.sin6_addr.s6_addr[13] = 0;
+    data_.v6.sin6_addr.s6_addr[14] = 0, data_.v6.sin6_addr.s6_addr[15] = 0;
+    data_.v6.sin6_scope_id = 0;
+  }
+}
+
+endpoint::endpoint(const boost::asio::ip::address& addr,
+    unsigned short port_num)
+  : data_()
+{
+  using namespace std; // For memcpy.
+  if (addr.is_v4())
+  {
+    data_.v4.sin_family = AF_INET;
+    data_.v4.sin_port =
+      boost::asio::detail::socket_ops::host_to_network_short(port_num);
+    data_.v4.sin_addr.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          addr.to_v4().to_ulong());
+  }
+  else
+  {
+    data_.v6.sin6_family = AF_INET6;
+    data_.v6.sin6_port =
+      boost::asio::detail::socket_ops::host_to_network_short(port_num);
+    data_.v6.sin6_flowinfo = 0;
+    boost::asio::ip::address_v6 v6_addr = addr.to_v6();
+    boost::asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
+    memcpy(data_.v6.sin6_addr.s6_addr, bytes.data(), 16);
+    data_.v6.sin6_scope_id = v6_addr.scope_id();
+  }
+}
+
+void endpoint::resize(std::size_t new_size)
+{
+  if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
+  {
+    boost::system::error_code ec(boost::asio::error::invalid_argument);
+    boost::asio::detail::throw_error(ec);
+  }
+}
+
+unsigned short endpoint::port() const
+{
+  if (is_v4())
+  {
+    return boost::asio::detail::socket_ops::network_to_host_short(
+        data_.v4.sin_port);
+  }
+  else
+  {
+    return boost::asio::detail::socket_ops::network_to_host_short(
+        data_.v6.sin6_port);
+  }
+}
+
+void endpoint::port(unsigned short port_num)
+{
+  if (is_v4())
+  {
+    data_.v4.sin_port
+      = boost::asio::detail::socket_ops::host_to_network_short(port_num);
+  }
+  else
+  {
+    data_.v6.sin6_port
+      = boost::asio::detail::socket_ops::host_to_network_short(port_num);
+  }
+}
+
+boost::asio::ip::address endpoint::address() const
+{
+  using namespace std; // For memcpy.
+  if (is_v4())
+  {
+    return boost::asio::ip::address_v4(
+        boost::asio::detail::socket_ops::network_to_host_long(
+          data_.v4.sin_addr.s_addr));
+  }
+  else
+  {
+    boost::asio::ip::address_v6::bytes_type bytes;
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+    memcpy(bytes.data(), data_.v6.sin6_addr.s6_addr, 16);
+#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
+    memcpy(bytes.elems, data_.v6.sin6_addr.s6_addr, 16);
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+    return boost::asio::ip::address_v6(bytes, data_.v6.sin6_scope_id);
+  }
+}
+
+void endpoint::address(const boost::asio::ip::address& addr)
+{
+  endpoint tmp_endpoint(addr, port());
+  data_ = tmp_endpoint.data_;
+}
+
+bool operator==(const endpoint& e1, const endpoint& e2)
+{
+  return e1.address() == e2.address() && e1.port() == e2.port();
+}
+
+bool operator<(const endpoint& e1, const endpoint& e2)
+{
+  if (e1.address() < e2.address())
+    return true;
+  if (e1.address() != e2.address())
+    return false;
+  return e1.port() < e2.port();
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+std::string endpoint::to_string(boost::system::error_code& ec) const
+{
+  std::string a = address().to_string(ec);
+  if (ec)
+    return std::string();
+
+  std::ostringstream tmp_os;
+  tmp_os.imbue(std::locale::classic());
+  if (is_v4())
+    tmp_os << a;
+  else
+    tmp_os << '[' << a << ']';
+  tmp_os << ':' << port();
+
+  return tmp_os.str();
+}
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace detail
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP

test/external/boost/asio/ip/detail/socket_option.hpp

@@ -0,0 +1,568 @@
+//
+// detail/socket_option.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
+#define BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cstddef>
+#include <cstring>
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/ip/address.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+namespace detail {
+namespace socket_option {
+
+// Helper template for implementing multicast enable loopback options.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class multicast_enable_loopback
+{
+public:
+#if defined(__sun) || defined(__osf__)
+  typedef unsigned char ipv4_value_type;
+  typedef unsigned char ipv6_value_type;
+#elif defined(_AIX) || defined(__hpux) || defined(__QNXNTO__) 
+  typedef unsigned char ipv4_value_type;
+  typedef unsigned int ipv6_value_type;
+#else
+  typedef int ipv4_value_type;
+  typedef int ipv6_value_type;
+#endif
+
+  // Default constructor.
+  multicast_enable_loopback()
+    : ipv4_value_(0),
+      ipv6_value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  explicit multicast_enable_loopback(bool v)
+    : ipv4_value_(v ? 1 : 0),
+      ipv6_value_(v ? 1 : 0)
+  {
+  }
+
+  // Set the value of the boolean.
+  multicast_enable_loopback& operator=(bool v)
+  {
+    ipv4_value_ = v ? 1 : 0;
+    ipv6_value_ = v ? 1 : 0;
+    return *this;
+  }
+
+  // Get the current value of the boolean.
+  bool value() const
+  {
+    return !!ipv4_value_;
+  }
+
+  // Convert to bool.
+  operator bool() const
+  {
+    return !!ipv4_value_;
+  }
+
+  // Test for false.
+  bool operator!() const
+  {
+    return !ipv4_value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the boolean data.
+  template <typename Protocol>
+  void* data(const Protocol& protocol)
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the address of the boolean data.
+  template <typename Protocol>
+  const void* data(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the size of the boolean data.
+  template <typename Protocol>
+  std::size_t size(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return sizeof(ipv6_value_);
+    return sizeof(ipv4_value_);
+  }
+
+  // Set the size of the boolean data.
+  template <typename Protocol>
+  void resize(const Protocol& protocol, std::size_t s)
+  {
+    if (protocol.family() == PF_INET6)
+    {
+      if (s != sizeof(ipv6_value_))
+      {
+        std::length_error ex("multicast_enable_loopback socket option resize");
+        boost::throw_exception(ex);
+      }
+      ipv4_value_ = ipv6_value_ ? 1 : 0;
+    }
+    else
+    {
+      if (s != sizeof(ipv4_value_))
+      {
+        std::length_error ex("multicast_enable_loopback socket option resize");
+        boost::throw_exception(ex);
+      }
+      ipv6_value_ = ipv4_value_ ? 1 : 0;
+    }
+  }
+
+private:
+  ipv4_value_type ipv4_value_;
+  ipv6_value_type ipv6_value_;
+};
+
+// Helper template for implementing unicast hops options.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class unicast_hops
+{
+public:
+  // Default constructor.
+  unicast_hops()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  explicit unicast_hops(int v)
+    : value_(v)
+  {
+  }
+
+  // Set the value of the option.
+  unicast_hops& operator=(int v)
+  {
+    value_ = v;
+    return *this;
+  }
+
+  // Get the current value of the option.
+  int value() const
+  {
+    return value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the data.
+  template <typename Protocol>
+  int* data(const Protocol&)
+  {
+    return &value_;
+  }
+
+  // Get the address of the data.
+  template <typename Protocol>
+  const int* data(const Protocol&) const
+  {
+    return &value_;
+  }
+
+  // Get the size of the data.
+  template <typename Protocol>
+  std::size_t size(const Protocol&) const
+  {
+    return sizeof(value_);
+  }
+
+  // Set the size of the data.
+  template <typename Protocol>
+  void resize(const Protocol&, std::size_t s)
+  {
+    if (s != sizeof(value_))
+    {
+      std::length_error ex("unicast hops socket option resize");
+      boost::throw_exception(ex);
+    }
+#if defined(__hpux)
+    if (value_ < 0)
+      value_ = value_ & 0xFF;
+#endif
+  }
+
+private:
+  int value_;
+};
+
+// Helper template for implementing multicast hops options.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class multicast_hops
+{
+public:
+#if defined(BOOST_WINDOWS) && defined(UNDER_CE)
+  typedef int ipv4_value_type;
+#else
+  typedef unsigned char ipv4_value_type;
+#endif
+  typedef int ipv6_value_type;
+
+  // Default constructor.
+  multicast_hops()
+    : ipv4_value_(0),
+      ipv6_value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  explicit multicast_hops(int v)
+  {
+    if (v < 0 || v > 255)
+    {
+      std::out_of_range ex("multicast hops value out of range");
+      boost::throw_exception(ex);
+    }
+    ipv4_value_ = (ipv4_value_type)v;
+    ipv6_value_ = v;
+  }
+
+  // Set the value of the option.
+  multicast_hops& operator=(int v)
+  {
+    if (v < 0 || v > 255)
+    {
+      std::out_of_range ex("multicast hops value out of range");
+      boost::throw_exception(ex);
+    }
+    ipv4_value_ = (ipv4_value_type)v;
+    ipv6_value_ = v;
+    return *this;
+  }
+
+  // Get the current value of the option.
+  int value() const
+  {
+    return ipv6_value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the data.
+  template <typename Protocol>
+  void* data(const Protocol& protocol)
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the address of the data.
+  template <typename Protocol>
+  const void* data(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the size of the data.
+  template <typename Protocol>
+  std::size_t size(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return sizeof(ipv6_value_);
+    return sizeof(ipv4_value_);
+  }
+
+  // Set the size of the data.
+  template <typename Protocol>
+  void resize(const Protocol& protocol, std::size_t s)
+  {
+    if (protocol.family() == PF_INET6)
+    {
+      if (s != sizeof(ipv6_value_))
+      {
+        std::length_error ex("multicast hops socket option resize");
+        boost::throw_exception(ex);
+      }
+      if (ipv6_value_ < 0)
+        ipv4_value_ = 0;
+      else if (ipv6_value_ > 255)
+        ipv4_value_ = 255;
+      else
+        ipv4_value_ = (ipv4_value_type)ipv6_value_;
+    }
+    else
+    {
+      if (s != sizeof(ipv4_value_))
+      {
+        std::length_error ex("multicast hops socket option resize");
+        boost::throw_exception(ex);
+      }
+      ipv6_value_ = ipv4_value_;
+    }
+  }
+
+private:
+  ipv4_value_type ipv4_value_;
+  ipv6_value_type ipv6_value_;
+};
+
+// Helper template for implementing ip_mreq-based options.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class multicast_request
+{
+public:
+  // Default constructor.
+  multicast_request()
+    : ipv4_value_(), // Zero-initialisation gives the "any" address.
+      ipv6_value_() // Zero-initialisation gives the "any" address.
+  {
+  }
+
+  // Construct with multicast address only.
+  explicit multicast_request(const boost::asio::ip::address& multicast_address)
+    : ipv4_value_(), // Zero-initialisation gives the "any" address.
+      ipv6_value_() // Zero-initialisation gives the "any" address.
+  {
+    if (multicast_address.is_v6())
+    {
+      using namespace std; // For memcpy.
+      boost::asio::ip::address_v6 ipv6_address = multicast_address.to_v6();
+      boost::asio::ip::address_v6::bytes_type bytes = ipv6_address.to_bytes();
+      memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
+      ipv6_value_.ipv6mr_interface = 0;
+    }
+    else
+    {
+      ipv4_value_.imr_multiaddr.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            multicast_address.to_v4().to_ulong());
+      ipv4_value_.imr_interface.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            boost::asio::ip::address_v4::any().to_ulong());
+    }
+  }
+
+  // Construct with multicast address and IPv4 address specifying an interface.
+  explicit multicast_request(
+      const boost::asio::ip::address_v4& multicast_address,
+      const boost::asio::ip::address_v4& network_interface
+        = boost::asio::ip::address_v4::any())
+    : ipv6_value_() // Zero-initialisation gives the "any" address.
+  {
+    ipv4_value_.imr_multiaddr.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          multicast_address.to_ulong());
+    ipv4_value_.imr_interface.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          network_interface.to_ulong());
+  }
+
+  // Construct with multicast address and IPv6 network interface index.
+  explicit multicast_request(
+      const boost::asio::ip::address_v6& multicast_address,
+      unsigned long network_interface = 0)
+    : ipv4_value_() // Zero-initialisation gives the "any" address.
+  {
+    using namespace std; // For memcpy.
+    boost::asio::ip::address_v6::bytes_type bytes =
+      multicast_address.to_bytes();
+    memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
+    ipv6_value_.ipv6mr_interface = network_interface;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the option data.
+  template <typename Protocol>
+  const void* data(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the size of the option data.
+  template <typename Protocol>
+  std::size_t size(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return sizeof(ipv6_value_);
+    return sizeof(ipv4_value_);
+  }
+
+private:
+  boost::asio::detail::in4_mreq_type ipv4_value_;
+  boost::asio::detail::in6_mreq_type ipv6_value_;
+};
+
+// Helper template for implementing options that specify a network interface.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class network_interface
+{
+public:
+  // Default constructor.
+  network_interface()
+  {
+    ipv4_value_.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv6_value_ = 0;
+  }
+
+  // Construct with IPv4 interface.
+  explicit network_interface(const boost::asio::ip::address_v4& ipv4_interface)
+  {
+    ipv4_value_.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          ipv4_interface.to_ulong());
+    ipv6_value_ = 0;
+  }
+
+  // Construct with IPv6 interface.
+  explicit network_interface(unsigned int ipv6_interface)
+  {
+    ipv4_value_.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv6_value_ = ipv6_interface;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the option data.
+  template <typename Protocol>
+  const void* data(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the size of the option data.
+  template <typename Protocol>
+  std::size_t size(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return sizeof(ipv6_value_);
+    return sizeof(ipv4_value_);
+  }
+
+private:
+  boost::asio::detail::in4_addr_type ipv4_value_;
+  unsigned int ipv6_value_;
+};
+
+} // namespace socket_option
+} // namespace detail
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP

test/external/boost/asio/ip/host_name.hpp

@@ -0,0 +1,44 @@
+//
+// ip/host_name.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_HOST_NAME_HPP
+#define BOOST_ASIO_IP_HOST_NAME_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+#include <boost/system/error_code.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Get the current host name.
+BOOST_ASIO_DECL std::string host_name();
+
+/// Get the current host name.
+BOOST_ASIO_DECL std::string host_name(boost::system::error_code& ec);
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/ip/impl/host_name.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_IP_HOST_NAME_HPP

test/external/boost/asio/ip/icmp.hpp

@@ -0,0 +1,115 @@
+//
+// ip/icmp.hpp
+// ~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_ICMP_HPP
+#define BOOST_ASIO_IP_ICMP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/basic_raw_socket.hpp>
+#include <boost/asio/ip/basic_endpoint.hpp>
+#include <boost/asio/ip/basic_resolver.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Encapsulates the flags needed for ICMP.
+/**
+ * The boost::asio::ip::icmp class contains flags necessary for ICMP sockets.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol, InternetProtocol.
+ */
+class icmp
+{
+public:
+  /// The type of a ICMP endpoint.
+  typedef basic_endpoint<icmp> endpoint;
+
+  /// Construct to represent the IPv4 ICMP protocol.
+  static icmp v4()
+  {
+    return icmp(IPPROTO_ICMP, PF_INET);
+  }
+
+  /// Construct to represent the IPv6 ICMP protocol.
+  static icmp v6()
+  {
+    return icmp(IPPROTO_ICMPV6, PF_INET6);
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return SOCK_RAW;
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return protocol_;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// The ICMP socket type.
+  typedef basic_raw_socket<icmp> socket;
+
+  /// The ICMP resolver type.
+  typedef basic_resolver<icmp> resolver;
+
+  /// Compare two protocols for equality.
+  friend bool operator==(const icmp& p1, const icmp& p2)
+  {
+    return p1.protocol_ == p2.protocol_ && p1.family_ == p2.family_;
+  }
+
+  /// Compare two protocols for inequality.
+  friend bool operator!=(const icmp& p1, const icmp& p2)
+  {
+    return p1.protocol_ != p2.protocol_ || p1.family_ != p2.family_;
+  }
+
+private:
+  // Construct with a specific family.
+  explicit icmp(int protocol_id, int protocol_family)
+    : protocol_(protocol_id),
+      family_(protocol_family)
+  {
+  }
+
+  int protocol_;
+  int family_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_ICMP_HPP

test/external/boost/asio/ip/impl/address.hpp

@@ -0,0 +1,55 @@
+//
+// ip/impl/address.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_ADDRESS_HPP
+#define BOOST_ASIO_IP_IMPL_ADDRESS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address& addr)
+{
+  boost::system::error_code ec;
+  std::string s = addr.to_string(ec);
+  if (ec)
+  {
+    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+      boost::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
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#endif // BOOST_ASIO_IP_IMPL_ADDRESS_HPP

test/external/boost/asio/ip/impl/address.ipp

@@ -0,0 +1,228 @@
+//
+// ip/impl/address.ipp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_ADDRESS_IPP
+#define BOOST_ASIO_IP_IMPL_ADDRESS_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <typeinfo>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/ip/address.hpp>
+#include <boost/system/system_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+address::address()
+  : type_(ipv4),
+    ipv4_address_(),
+    ipv6_address_()
+{
+}
+
+address::address(const boost::asio::ip::address_v4& ipv4_address)
+  : type_(ipv4),
+    ipv4_address_(ipv4_address),
+    ipv6_address_()
+{
+}
+
+address::address(const boost::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(BOOST_ASIO_HAS_MOVE)
+address::address(address&& other)
+  : type_(other.type_),
+    ipv4_address_(other.ipv4_address_),
+    ipv6_address_(other.ipv6_address_)
+{
+}
+#endif // defined(BOOST_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(BOOST_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(BOOST_ASIO_HAS_MOVE)
+
+address& address::operator=(const boost::asio::ip::address_v4& ipv4_address)
+{
+  type_ = ipv4;
+  ipv4_address_ = ipv4_address;
+  ipv6_address_ = boost::asio::ip::address_v6();
+  return *this;
+}
+
+address& address::operator=(const boost::asio::ip::address_v6& ipv6_address)
+{
+  type_ = ipv6;
+  ipv4_address_ = boost::asio::ip::address_v4();
+  ipv6_address_ = ipv6_address;
+  return *this;
+}
+
+boost::asio::ip::address_v4 address::to_v4() const
+{
+  if (type_ != ipv4)
+  {
+    std::bad_cast ex;
+    boost::throw_exception(ex);
+  }
+  return ipv4_address_;
+}
+
+boost::asio::ip::address_v6 address::to_v6() const
+{
+  if (type_ != ipv6)
+  {
+    std::bad_cast ex;
+    boost::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();
+}
+
+std::string address::to_string(boost::system::error_code& ec) const
+{
+  if (type_ == ipv6)
+    return ipv6_address_.to_string(ec);
+  return ipv4_address_.to_string(ec);
+}
+
+address address::from_string(const char* str)
+{
+  boost::system::error_code ec;
+  address addr = from_string(str, ec);
+  boost::asio::detail::throw_error(ec);
+  return addr;
+}
+
+address address::from_string(const char* str, boost::system::error_code& ec)
+{
+  boost::asio::ip::address_v6 ipv6_address =
+    boost::asio::ip::address_v6::from_string(str, ec);
+  if (!ec)
+  {
+    address tmp;
+    tmp.type_ = ipv6;
+    tmp.ipv6_address_ = ipv6_address;
+    return tmp;
+  }
+
+  boost::asio::ip::address_v4 ipv4_address =
+    boost::asio::ip::address_v4::from_string(str, ec);
+  if (!ec)
+  {
+    address tmp;
+    tmp.type_ = ipv4;
+    tmp.ipv4_address_ = ipv4_address;
+    return tmp;
+  }
+
+  return address();
+}
+
+address address::from_string(const std::string& str)
+{
+  return from_string(str.c_str());
+}
+
+address address::from_string(const std::string& str,
+    boost::system::error_code& ec)
+{
+  return from_string(str.c_str(), ec);
+}
+
+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
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_IMPL_ADDRESS_IPP

test/external/boost/asio/ip/impl/address_v4.hpp

@@ -0,0 +1,55 @@
+//
+// ip/impl/address_v4.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
+#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
+{
+  boost::system::error_code ec;
+  std::string s = addr.to_string(ec);
+  if (ec)
+  {
+    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+      boost::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
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#endif // BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP

test/external/boost/asio/ip/impl/address_v4.ipp

@@ -0,0 +1,178 @@
+//
+// ip/impl/address_v4.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
+#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <climits>
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/ip/address_v4.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+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");
+    boost::throw_exception(ex);
+  }
+#endif // UCHAR_MAX > 0xFF
+
+  using namespace std; // For memcpy.
+  memcpy(&addr_.s_addr, bytes.data(), 4);
+}
+
+address_v4::address_v4(unsigned long addr)
+{
+#if ULONG_MAX > 0xFFFFFFFF
+  if (addr > 0xFFFFFFFF)
+  {
+    std::out_of_range ex("address_v4 from unsigned long");
+    boost::throw_exception(ex);
+  }
+#endif // ULONG_MAX > 0xFFFFFFFF
+
+  addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(addr);
+}
+
+address_v4::bytes_type address_v4::to_bytes() const
+{
+  using namespace std; // For memcpy.
+  bytes_type bytes;
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+  memcpy(bytes.data(), &addr_.s_addr, 4);
+#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
+  memcpy(bytes.elems, &addr_.s_addr, 4);
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+  return bytes;
+}
+
+unsigned long address_v4::to_ulong() const
+{
+  return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
+}
+
+std::string address_v4::to_string() const
+{
+  boost::system::error_code ec;
+  std::string addr = to_string(ec);
+  boost::asio::detail::throw_error(ec);
+  return addr;
+}
+
+std::string address_v4::to_string(boost::system::error_code& ec) const
+{
+  char addr_str[boost::asio::detail::max_addr_v4_str_len];
+  const char* addr =
+    boost::asio::detail::socket_ops::inet_ntop(AF_INET, &addr_, addr_str,
+        boost::asio::detail::max_addr_v4_str_len, 0, ec);
+  if (addr == 0)
+    return std::string();
+  return addr;
+}
+
+address_v4 address_v4::from_string(const char* str)
+{
+  boost::system::error_code ec;
+  address_v4 addr = from_string(str, ec);
+  boost::asio::detail::throw_error(ec);
+  return addr;
+}
+
+address_v4 address_v4::from_string(
+    const char* str, boost::system::error_code& ec)
+{
+  address_v4 tmp;
+  if (boost::asio::detail::socket_ops::inet_pton(
+        AF_INET, str, &tmp.addr_, 0, ec) <= 0)
+    return address_v4();
+  return tmp;
+}
+
+address_v4 address_v4::from_string(const std::string& str)
+{
+  return from_string(str.c_str());
+}
+
+address_v4 address_v4::from_string(
+    const std::string& str, boost::system::error_code& ec)
+{
+  return from_string(str.c_str(), ec);
+}
+
+bool address_v4::is_loopback() const
+{
+  return (to_ulong() & 0xFF000000) == 0x7F000000;
+}
+
+bool address_v4::is_unspecified() const
+{
+  return to_ulong() == 0;
+}
+
+bool address_v4::is_class_a() const
+{
+  return (to_ulong() & 0x80000000) == 0;
+}
+
+bool address_v4::is_class_b() const
+{
+  return (to_ulong() & 0xC0000000) == 0x80000000;
+}
+
+bool address_v4::is_class_c() const
+{
+  return (to_ulong() & 0xE0000000) == 0xC0000000;
+}
+
+bool address_v4::is_multicast() const
+{
+  return (to_ulong() & 0xF0000000) == 0xE0000000;
+}
+
+address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
+{
+  return address_v4(addr.to_ulong() | (mask.to_ulong() ^ 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);
+}
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP

test/external/boost/asio/ip/impl/address_v6.hpp

@@ -0,0 +1,55 @@
+//
+// ip/impl/address_v6.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
+#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
+{
+  boost::system::error_code ec;
+  std::string s = addr.to_string(ec);
+  if (ec)
+  {
+    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+      boost::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
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#endif // BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP

test/external/boost/asio/ip/impl/address_v6.ipp

@@ -0,0 +1,299 @@
+//
+// ip/impl/address_v6.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP
+#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cstring>
+#include <stdexcept>
+#include <typeinfo>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/ip/address_v6.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+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");
+      boost::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(BOOST_ASIO_HAS_MOVE)
+address_v6::address_v6(address_v6&& other)
+  : addr_(other.addr_),
+    scope_id_(other.scope_id_)
+{
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+address_v6& address_v6::operator=(const address_v6& other)
+{
+  addr_ = other.addr_;
+  scope_id_ = other.scope_id_;
+  return *this;
+}
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+address_v6& address_v6::operator=(address_v6&& other)
+{
+  addr_ = other.addr_;
+  scope_id_ = other.scope_id_;
+  return *this;
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+address_v6::bytes_type address_v6::to_bytes() const
+{
+  using namespace std; // For memcpy.
+  bytes_type bytes;
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+  memcpy(bytes.data(), addr_.s6_addr, 16);
+#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
+  memcpy(bytes.elems, addr_.s6_addr, 16);
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+  return bytes;
+}
+
+std::string address_v6::to_string() const
+{
+  boost::system::error_code ec;
+  std::string addr = to_string(ec);
+  boost::asio::detail::throw_error(ec);
+  return addr;
+}
+
+std::string address_v6::to_string(boost::system::error_code& ec) const
+{
+  char addr_str[boost::asio::detail::max_addr_v6_str_len];
+  const char* addr =
+    boost::asio::detail::socket_ops::inet_ntop(AF_INET6, &addr_, addr_str,
+        boost::asio::detail::max_addr_v6_str_len, scope_id_, ec);
+  if (addr == 0)
+    return std::string();
+  return addr;
+}
+
+address_v6 address_v6::from_string(const char* str)
+{
+  boost::system::error_code ec;
+  address_v6 addr = from_string(str, ec);
+  boost::asio::detail::throw_error(ec);
+  return addr;
+}
+
+address_v6 address_v6::from_string(
+    const char* str, boost::system::error_code& ec)
+{
+  address_v6 tmp;
+  if (boost::asio::detail::socket_ops::inet_pton(
+        AF_INET6, str, &tmp.addr_, &tmp.scope_id_, ec) <= 0)
+    return address_v6();
+  return tmp;
+}
+
+address_v6 address_v6::from_string(const std::string& str)
+{
+  return from_string(str.c_str());
+}
+
+address_v6 address_v6::from_string(
+    const std::string& str, boost::system::error_code& ec)
+{
+  return from_string(str.c_str(), ec);
+}
+
+address_v4 address_v6::to_v4() const
+{
+  if (!is_v4_mapped() && !is_v4_compatible())
+  {
+    std::bad_cast ex;
+    boost::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);
+}
+
+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));
+}
+
+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))));
+}
+
+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(boost::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(boost::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;
+}
+
+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);
+}
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP

test/external/boost/asio/ip/impl/basic_endpoint.hpp

@@ -0,0 +1,57 @@
+//
+// ip/impl/basic_endpoint.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
+#define BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+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)
+{
+  boost::asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
+  boost::system::error_code ec;
+  std::string s = tmp_ep.to_string(ec);
+  if (ec)
+  {
+    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+      boost::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
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+#endif // BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP

test/external/boost/asio/ip/impl/host_name.ipp

@@ -0,0 +1,56 @@
+//
+// ip/impl/host_name.ipp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_IMPL_HOST_NAME_IPP
+#define BOOST_ASIO_IP_IMPL_HOST_NAME_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/winsock_init.hpp>
+#include <boost/asio/ip/host_name.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+std::string host_name()
+{
+  char name[1024];
+  boost::system::error_code ec;
+  if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
+  {
+    boost::asio::detail::throw_error(ec);
+    return std::string();
+  }
+  return std::string(name);
+}
+
+std::string host_name(boost::system::error_code& ec)
+{
+  char name[1024];
+  if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
+    return std::string();
+  return std::string(name);
+}
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_IMPL_HOST_NAME_IPP

test/external/boost/asio/ip/multicast.hpp

@@ -0,0 +1,180 @@
+//
+// ip/multicast.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_MULTICAST_HPP
+#define BOOST_ASIO_IP_MULTICAST_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cstddef>
+#include <boost/asio/ip/detail/socket_option.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+namespace multicast {
+
+/// Socket option to join a multicast group on a specified interface.
+/**
+ * Implements the IPPROTO_IP/IP_ADD_MEMBERSHIP socket option.
+ *
+ * @par Examples
+ * Setting the option to join a multicast group:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::address multicast_address =
+ *   boost::asio::ip::address::from_string("225.0.0.1");
+ * boost::asio::ip::multicast::join_group option(multicast_address);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par Concepts:
+ * SettableSocketOption.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined join_group;
+#else
+typedef boost::asio::ip::detail::socket_option::multicast_request<
+  IPPROTO_IP, IP_ADD_MEMBERSHIP, IPPROTO_IPV6, IPV6_JOIN_GROUP> join_group;
+#endif
+
+/// Socket option to leave a multicast group on a specified interface.
+/**
+ * Implements the IPPROTO_IP/IP_DROP_MEMBERSHIP socket option.
+ *
+ * @par Examples
+ * Setting the option to leave a multicast group:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::address multicast_address =
+ *   boost::asio::ip::address::from_string("225.0.0.1");
+ * boost::asio::ip::multicast::leave_group option(multicast_address);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par Concepts:
+ * SettableSocketOption.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined leave_group;
+#else
+typedef boost::asio::ip::detail::socket_option::multicast_request<
+  IPPROTO_IP, IP_DROP_MEMBERSHIP, IPPROTO_IPV6, IPV6_LEAVE_GROUP> leave_group;
+#endif
+
+/// Socket option for local interface to use for outgoing multicast packets.
+/**
+ * Implements the IPPROTO_IP/IP_MULTICAST_IF socket option.
+ *
+ * @par Examples
+ * Setting the option:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::address_v4 local_interface =
+ *   boost::asio::ip::address_v4::from_string("1.2.3.4");
+ * boost::asio::ip::multicast::outbound_interface option(local_interface);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par Concepts:
+ * SettableSocketOption.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined outbound_interface;
+#else
+typedef boost::asio::ip::detail::socket_option::network_interface<
+  IPPROTO_IP, IP_MULTICAST_IF, IPPROTO_IPV6, IPV6_MULTICAST_IF>
+  outbound_interface;
+#endif
+
+/// Socket option for time-to-live associated with outgoing multicast packets.
+/**
+ * Implements the IPPROTO_IP/IP_MULTICAST_TTL socket option.
+ *
+ * @par Examples
+ * Setting the option:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::hops option(4);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par
+ * Getting the current option value:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::hops option;
+ * socket.get_option(option);
+ * int ttl = option.value();
+ * @endcode
+ *
+ * @par Concepts:
+ * GettableSocketOption, SettableSocketOption.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined hops;
+#else
+typedef boost::asio::ip::detail::socket_option::multicast_hops<
+  IPPROTO_IP, IP_MULTICAST_TTL, IPPROTO_IPV6, IPV6_MULTICAST_HOPS> hops;
+#endif
+
+/// Socket option determining whether outgoing multicast packets will be
+/// received on the same socket if it is a member of the multicast group.
+/**
+ * Implements the IPPROTO_IP/IP_MULTICAST_LOOP socket option.
+ *
+ * @par Examples
+ * Setting the option:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::enable_loopback option(true);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par
+ * Getting the current option value:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::enable_loopback option;
+ * socket.get_option(option);
+ * bool is_set = option.value();
+ * @endcode
+ *
+ * @par Concepts:
+ * GettableSocketOption, SettableSocketOption.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined enable_loopback;
+#else
+typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
+  IPPROTO_IP, IP_MULTICAST_LOOP, IPPROTO_IPV6, IPV6_MULTICAST_LOOP>
+  enable_loopback;
+#endif
+
+} // namespace multicast
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_MULTICAST_HPP

test/external/boost/asio/ip/resolver_query_base.hpp

@@ -0,0 +1,157 @@
+//
+// ip/resolver_query_base.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
+#define BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// The resolver_query_base class is used as a base for the
+/// basic_resolver_query class templates to provide a common place to define
+/// the flag constants.
+class resolver_query_base
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// A bitmask type (C++ Std [lib.bitmask.types]).
+  typedef unspecified flags;
+
+  /// Determine the canonical name of the host specified in the query.
+  static const flags canonical_name = implementation_defined;
+
+  /// Indicate that returned endpoint is intended for use as a locally bound
+  /// socket endpoint.
+  static const flags passive = implementation_defined;
+
+  /// Host name should be treated as a numeric string defining an IPv4 or IPv6
+  /// address and no name resolution should be attempted.
+  static const flags numeric_host = implementation_defined;
+
+  /// Service name should be treated as a numeric string defining a port number
+  /// and no name resolution should be attempted.
+  static const flags numeric_service = implementation_defined;
+
+  /// If the query protocol family is specified as IPv6, return IPv4-mapped
+  /// IPv6 addresses on finding no IPv6 addresses.
+  static const flags v4_mapped = implementation_defined;
+
+  /// If used with v4_mapped, return all matching IPv6 and IPv4 addresses.
+  static const flags all_matching = implementation_defined;
+
+  /// Only return IPv4 addresses if a non-loopback IPv4 address is configured
+  /// for the system. Only return IPv6 addresses if a non-loopback IPv6 address
+  /// is configured for the system.
+  static const flags address_configured = implementation_defined;
+#else
+  enum flags
+  {
+    canonical_name = AI_CANONNAME,
+    passive = AI_PASSIVE,
+    numeric_host = AI_NUMERICHOST,
+# if defined(AI_NUMERICSERV)
+    numeric_service = AI_NUMERICSERV,
+# else
+    numeric_service = 0,
+# endif
+    // Note: QNX Neutrino 6.3 defines AI_V4MAPPED, AI_ALL and AI_ADDRCONFIG but
+    // does not implement them. Therefore they are specifically excluded here.
+# if defined(AI_V4MAPPED) && !defined(__QNXNTO__)
+    v4_mapped = AI_V4MAPPED,
+# else
+    v4_mapped = 0,
+# endif
+# if defined(AI_ALL) && !defined(__QNXNTO__)
+    all_matching = AI_ALL,
+# else
+    all_matching = 0,
+# endif
+# if defined(AI_ADDRCONFIG) && !defined(__QNXNTO__)
+    address_configured = AI_ADDRCONFIG
+# else
+    address_configured = 0
+# endif
+  };
+
+  // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
+
+  friend flags operator&(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
+  }
+
+  friend flags operator|(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
+  }
+
+  friend flags operator^(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
+  }
+
+  friend flags operator~(flags x)
+  {
+    return static_cast<flags>(static_cast<unsigned int>(~x));
+  }
+
+  friend flags& operator&=(flags& x, flags y)
+  {
+    x = x & y;
+    return x;
+  }
+
+  friend flags& operator|=(flags& x, flags y)
+  {
+    x = x | y;
+    return x;
+  }
+
+  friend flags& operator^=(flags& x, flags y)
+  {
+    x = x ^ y;
+    return x;
+  }
+#endif
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~resolver_query_base()
+  {
+  }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+private:
+  // Workaround to enable the empty base optimisation with Borland C++.
+  char dummy_;
+#endif
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP

test/external/boost/asio/ip/resolver_service.hpp

@@ -0,0 +1,153 @@
+//
+// ip/resolver_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_RESOLVER_SERVICE_HPP
+#define BOOST_ASIO_IP_RESOLVER_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/detail/resolver_service.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Default service implementation for a resolver.
+template <typename InternetProtocol>
+class resolver_service
+#if defined(GENERATING_DOCUMENTATION)
+  : public boost::asio::io_service::service
+#else
+  : public boost::asio::detail::service_base<
+      resolver_service<InternetProtocol> >
+#endif
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// The unique service identifier.
+  static boost::asio::io_service::id id;
+#endif
+
+  /// The protocol type.
+  typedef InternetProtocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename InternetProtocol::endpoint endpoint_type;
+
+  /// The query type.
+  typedef basic_resolver_query<InternetProtocol> query_type;
+
+  /// The iterator type.
+  typedef basic_resolver_iterator<InternetProtocol> iterator_type;
+
+private:
+  // The type of the platform-specific implementation.
+  typedef boost::asio::detail::resolver_service<InternetProtocol>
+    service_impl_type;
+
+public:
+  /// The type of a resolver implementation.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef typename service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// Construct a new resolver service for the specified io_service.
+  explicit resolver_service(boost::asio::io_service& io_service)
+    : boost::asio::detail::service_base<
+        resolver_service<InternetProtocol> >(io_service),
+      service_impl_(io_service)
+  {
+  }
+
+  /// Construct a new resolver implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a resolver implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Cancel pending asynchronous operations.
+  void cancel(implementation_type& impl)
+  {
+    service_impl_.cancel(impl);
+  }
+
+  /// Resolve a query to a list of entries.
+  iterator_type resolve(implementation_type& impl, const query_type& query,
+      boost::system::error_code& ec)
+  {
+    return service_impl_.resolve(impl, query, ec);
+  }
+
+  /// Asynchronously resolve a query to a list of entries.
+  template <typename ResolveHandler>
+  void async_resolve(implementation_type& impl, const query_type& query,
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    service_impl_.async_resolve(impl, query,
+        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+  }
+
+  /// Resolve an endpoint to a list of entries.
+  iterator_type resolve(implementation_type& impl,
+      const endpoint_type& endpoint, boost::system::error_code& ec)
+  {
+    return service_impl_.resolve(impl, endpoint, ec);
+  }
+
+  /// Asynchronously resolve an endpoint to a list of entries.
+  template <typename ResolveHandler>
+  void async_resolve(implementation_type& impl, const endpoint_type& endpoint,
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    return service_impl_.async_resolve(impl, endpoint,
+        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+  }
+
+private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
+  // Perform any fork-related housekeeping.
+  void fork_service(boost::asio::io_service::fork_event event)
+  {
+    service_impl_.fork_service(event);
+  }
+
+  // The platform-specific implementation.
+  service_impl_type service_impl_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_RESOLVER_SERVICE_HPP

test/external/boost/asio/ip/tcp.hpp

@@ -0,0 +1,157 @@
+//
+// ip/tcp.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_TCP_HPP
+#define BOOST_ASIO_IP_TCP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/basic_socket_acceptor.hpp>
+#include <boost/asio/basic_socket_iostream.hpp>
+#include <boost/asio/basic_stream_socket.hpp>
+#include <boost/asio/detail/socket_option.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/ip/basic_endpoint.hpp>
+#include <boost/asio/ip/basic_resolver.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Encapsulates the flags needed for TCP.
+/**
+ * The boost::asio::ip::tcp class contains flags necessary for TCP sockets.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol, InternetProtocol.
+ */
+class tcp
+{
+public:
+  /// The type of a TCP endpoint.
+  typedef basic_endpoint<tcp> endpoint;
+
+  /// Construct to represent the IPv4 TCP protocol.
+  static tcp v4()
+  {
+    return tcp(PF_INET);
+  }
+
+  /// Construct to represent the IPv6 TCP protocol.
+  static tcp v6()
+  {
+    return tcp(PF_INET6);
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return SOCK_STREAM;
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return IPPROTO_TCP;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// The TCP socket type.
+  typedef basic_stream_socket<tcp> socket;
+
+  /// The TCP acceptor type.
+  typedef basic_socket_acceptor<tcp> acceptor;
+
+  /// The TCP resolver type.
+  typedef basic_resolver<tcp> resolver;
+
+#if !defined(BOOST_NO_IOSTREAM)
+  /// The TCP iostream type.
+  typedef basic_socket_iostream<tcp> iostream;
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+  /// Socket option for disabling the Nagle algorithm.
+  /**
+   * Implements the IPPROTO_TCP/TCP_NODELAY socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::ip::tcp::no_delay option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::ip::tcp::no_delay option;
+   * socket.get_option(option);
+   * bool is_set = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined no_delay;
+#else
+  typedef boost::asio::detail::socket_option::boolean<
+    IPPROTO_TCP, TCP_NODELAY> no_delay;
+#endif
+
+  /// Compare two protocols for equality.
+  friend bool operator==(const tcp& p1, const tcp& p2)
+  {
+    return p1.family_ == p2.family_;
+  }
+
+  /// Compare two protocols for inequality.
+  friend bool operator!=(const tcp& p1, const tcp& p2)
+  {
+    return p1.family_ != p2.family_;
+  }
+
+private:
+  // Construct with a specific family.
+  explicit tcp(int protocol_family)
+    : family_(protocol_family)
+  {
+  }
+
+  int family_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_TCP_HPP

test/external/boost/asio/ip/udp.hpp

@@ -0,0 +1,113 @@
+//
+// ip/udp.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_UDP_HPP
+#define BOOST_ASIO_IP_UDP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/basic_datagram_socket.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/ip/basic_endpoint.hpp>
+#include <boost/asio/ip/basic_resolver.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Encapsulates the flags needed for UDP.
+/**
+ * The boost::asio::ip::udp class contains flags necessary for UDP sockets.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol, InternetProtocol.
+ */
+class udp
+{
+public:
+  /// The type of a UDP endpoint.
+  typedef basic_endpoint<udp> endpoint;
+
+  /// Construct to represent the IPv4 UDP protocol.
+  static udp v4()
+  {
+    return udp(PF_INET);
+  }
+
+  /// Construct to represent the IPv6 UDP protocol.
+  static udp v6()
+  {
+    return udp(PF_INET6);
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return SOCK_DGRAM;
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return IPPROTO_UDP;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// The UDP socket type.
+  typedef basic_datagram_socket<udp> socket;
+
+  /// The UDP resolver type.
+  typedef basic_resolver<udp> resolver;
+
+  /// Compare two protocols for equality.
+  friend bool operator==(const udp& p1, const udp& p2)
+  {
+    return p1.family_ == p2.family_;
+  }
+
+  /// Compare two protocols for inequality.
+  friend bool operator!=(const udp& p1, const udp& p2)
+  {
+    return p1.family_ != p2.family_;
+  }
+
+private:
+  // Construct with a specific family.
+  explicit udp(int protocol_family)
+    : family_(protocol_family)
+  {
+  }
+
+  int family_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_UDP_HPP

test/external/boost/asio/ip/unicast.hpp

@@ -0,0 +1,69 @@
+//
+// ip/unicast.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_UNICAST_HPP
+#define BOOST_ASIO_IP_UNICAST_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cstddef>
+#include <boost/asio/ip/detail/socket_option.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+namespace unicast {
+
+/// Socket option for time-to-live associated with outgoing unicast packets.
+/**
+ * Implements the IPPROTO_IP/IP_UNICAST_TTL socket option.
+ *
+ * @par Examples
+ * Setting the option:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::unicast::hops option(4);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par
+ * Getting the current option value:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::unicast::hops option;
+ * socket.get_option(option);
+ * int ttl = option.value();
+ * @endcode
+ *
+ * @par Concepts:
+ * GettableSocketOption, SettableSocketOption.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined hops;
+#else
+typedef boost::asio::ip::detail::socket_option::unicast_hops<
+  IPPROTO_IP, IP_TTL, IPPROTO_IPV6, IPV6_UNICAST_HOPS> hops;
+#endif
+
+} // namespace unicast
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_UNICAST_HPP

test/external/boost/asio/ip/v6_only.hpp

@@ -0,0 +1,71 @@
+//
+// ip/v6_only.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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 BOOST_ASIO_IP_V6_ONLY_HPP
+#define BOOST_ASIO_IP_V6_ONLY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/socket_option.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Socket option for determining whether an IPv6 socket supports IPv6
+/// communication only.
+/**
+ * Implements the IPPROTO_IPV6/IP_V6ONLY socket option.
+ *
+ * @par Examples
+ * Setting the option:
+ * @code
+ * boost::asio::ip::tcp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::v6_only option(true);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par
+ * Getting the current option value:
+ * @code
+ * boost::asio::ip::tcp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::v6_only option;
+ * socket.get_option(option);
+ * bool v6_only = option.value();
+ * @endcode
+ *
+ * @par Concepts:
+ * GettableSocketOption, SettableSocketOption.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined v6_only;
+#elif defined(IPV6_V6ONLY)
+typedef boost::asio::detail::socket_option::boolean<
+    IPPROTO_IPV6, IPV6_V6ONLY> v6_only;
+#else
+typedef boost::asio::detail::socket_option::boolean<
+    boost::asio::detail::custom_socket_option_level,
+    boost::asio::detail::always_fail_option> v6_only;
+#endif
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_V6_ONLY_HPP