hadoop-common-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From whe...@apache.org
Subject [17/50] [abbrv] hadoop git commit: HDFS-8724. Import third_party libraries into the repository.
Date Tue, 07 Jul 2015 21:32:04 GMT
http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/socket_base.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/socket_base.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/socket_base.hpp
new file mode 100644
index 0000000..5412162
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/socket_base.hpp
@@ -0,0 +1,520 @@
+//
+// socket_base.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SOCKET_BASE_HPP
+#define ASIO_SOCKET_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/io_control.hpp"
+#include "asio/detail/socket_option.hpp"
+#include "asio/detail/socket_types.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// The socket_base class is used as a base for the basic_stream_socket and
+/// basic_datagram_socket class templates so that we have a common place to
+/// define the shutdown_type and enum.
+class socket_base
+{
+public:
+  /// Different ways a socket may be shutdown.
+  enum shutdown_type
+  {
+#if defined(GENERATING_DOCUMENTATION)
+    /// Shutdown the receive side of the socket.
+    shutdown_receive = implementation_defined,
+
+    /// Shutdown the send side of the socket.
+    shutdown_send = implementation_defined,
+
+    /// Shutdown both send and receive on the socket.
+    shutdown_both = implementation_defined
+#else
+    shutdown_receive = ASIO_OS_DEF(SHUT_RD),
+    shutdown_send = ASIO_OS_DEF(SHUT_WR),
+    shutdown_both = ASIO_OS_DEF(SHUT_RDWR)
+#endif
+  };
+
+  /// Bitmask type for flags that can be passed to send and receive operations.
+  typedef int message_flags;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// Peek at incoming data without removing it from the input queue.
+  static const int message_peek = implementation_defined;
+
+  /// Process out-of-band data.
+  static const int message_out_of_band = implementation_defined;
+
+  /// Specify that the data should not be subject to routing.
+  static const int message_do_not_route = implementation_defined;
+
+  /// Specifies that the data marks the end of a record.
+  static const int message_end_of_record = implementation_defined;
+#else
+  ASIO_STATIC_CONSTANT(int,
+      message_peek = ASIO_OS_DEF(MSG_PEEK));
+  ASIO_STATIC_CONSTANT(int,
+      message_out_of_band = ASIO_OS_DEF(MSG_OOB));
+  ASIO_STATIC_CONSTANT(int,
+      message_do_not_route = ASIO_OS_DEF(MSG_DONTROUTE));
+  ASIO_STATIC_CONSTANT(int,
+      message_end_of_record = ASIO_OS_DEF(MSG_EOR));
+#endif
+
+  /// Socket option to permit sending of broadcast messages.
+  /**
+   * Implements the SOL_SOCKET/SO_BROADCAST socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::udp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::broadcast option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::udp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::broadcast 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 broadcast;
+#else
+  typedef asio::detail::socket_option::boolean<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_BROADCAST)>
+      broadcast;
+#endif
+
+  /// Socket option to enable socket-level debugging.
+  /**
+   * Implements the SOL_SOCKET/SO_DEBUG socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::debug option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::debug 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 debug;
+#else
+  typedef asio::detail::socket_option::boolean<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_DEBUG)> debug;
+#endif
+
+  /// Socket option to prevent routing, use local interfaces only.
+  /**
+   * Implements the SOL_SOCKET/SO_DONTROUTE socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::udp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::do_not_route option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::udp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::do_not_route 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 do_not_route;
+#else
+  typedef asio::detail::socket_option::boolean<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_DONTROUTE)>
+      do_not_route;
+#endif
+
+  /// Socket option to send keep-alives.
+  /**
+   * Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::keep_alive option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::keep_alive 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 keep_alive;
+#else
+  typedef asio::detail::socket_option::boolean<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_KEEPALIVE)> keep_alive;
+#endif
+
+  /// Socket option for the send buffer size of a socket.
+  /**
+   * Implements the SOL_SOCKET/SO_SNDBUF socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::send_buffer_size option(8192);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::send_buffer_size option;
+   * socket.get_option(option);
+   * int size = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined send_buffer_size;
+#else
+  typedef asio::detail::socket_option::integer<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_SNDBUF)>
+      send_buffer_size;
+#endif
+
+  /// Socket option for the send low watermark.
+  /**
+   * Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::send_low_watermark option(1024);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::send_low_watermark option;
+   * socket.get_option(option);
+   * int size = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined send_low_watermark;
+#else
+  typedef asio::detail::socket_option::integer<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_SNDLOWAT)>
+      send_low_watermark;
+#endif
+
+  /// Socket option for the receive buffer size of a socket.
+  /**
+   * Implements the SOL_SOCKET/SO_RCVBUF socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::receive_buffer_size option(8192);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::receive_buffer_size option;
+   * socket.get_option(option);
+   * int size = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined receive_buffer_size;
+#else
+  typedef asio::detail::socket_option::integer<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_RCVBUF)>
+      receive_buffer_size;
+#endif
+
+  /// Socket option for the receive low watermark.
+  /**
+   * Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::receive_low_watermark option(1024);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::receive_low_watermark option;
+   * socket.get_option(option);
+   * int size = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined receive_low_watermark;
+#else
+  typedef asio::detail::socket_option::integer<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_RCVLOWAT)>
+      receive_low_watermark;
+#endif
+
+  /// Socket option to allow the socket to be bound to an address that is
+  /// already in use.
+  /**
+   * Implements the SOL_SOCKET/SO_REUSEADDR socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * ...
+   * asio::socket_base::reuse_address option(true);
+   * acceptor.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * ...
+   * asio::socket_base::reuse_address option;
+   * acceptor.get_option(option);
+   * bool is_set = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined reuse_address;
+#else
+  typedef asio::detail::socket_option::boolean<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_REUSEADDR)>
+      reuse_address;
+#endif
+
+  /// Socket option to specify whether the socket lingers on close if unsent
+  /// data is present.
+  /**
+   * Implements the SOL_SOCKET/SO_LINGER socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::linger option(true, 30);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::linger option;
+   * socket.get_option(option);
+   * bool is_set = option.enabled();
+   * unsigned short timeout = option.timeout();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Linger_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined linger;
+#else
+  typedef asio::detail::socket_option::linger<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_LINGER)>
+      linger;
+#endif
+
+  /// Socket option to report aborted connections on accept.
+  /**
+   * Implements a custom socket option that determines whether or not an accept
+   * operation is permitted to fail with asio::error::connection_aborted.
+   * By default the option is false.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * ...
+   * asio::socket_base::enable_connection_aborted option(true);
+   * acceptor.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * ...
+   * asio::socket_base::enable_connection_aborted option;
+   * acceptor.get_option(option);
+   * bool is_set = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined enable_connection_aborted;
+#else
+  typedef asio::detail::socket_option::boolean<
+    asio::detail::custom_socket_option_level,
+    asio::detail::enable_connection_aborted_option>
+    enable_connection_aborted;
+#endif
+
+  /// (Deprecated: Use non_blocking().) IO control command to
+  /// set the blocking mode of the socket.
+  /**
+   * Implements the FIONBIO IO control command.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::non_blocking_io command(true);
+   * socket.io_control(command);
+   * @endcode
+   *
+   * @par Concepts:
+   * IO_Control_Command, Boolean_IO_Control_Command.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined non_blocking_io;
+#else
+  typedef asio::detail::io_control::non_blocking_io non_blocking_io;
+#endif
+
+  /// IO control command to get the amount of data that can be read without
+  /// blocking.
+  /**
+   * Implements the FIONREAD IO control command.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * asio::socket_base::bytes_readable command(true);
+   * socket.io_control(command);
+   * std::size_t bytes_readable = command.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * IO_Control_Command, Size_IO_Control_Command.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined bytes_readable;
+#else
+  typedef asio::detail::io_control::bytes_readable bytes_readable;
+#endif
+
+  /// The maximum length of the queue of pending incoming connections.
+#if defined(GENERATING_DOCUMENTATION)
+  static const int max_connections = implementation_defined;
+#else
+  ASIO_STATIC_CONSTANT(int, max_connections
+      = ASIO_OS_DEF(SOMAXCONN));
+#endif
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~socket_base()
+  {
+  }
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SOCKET_BASE_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/spawn.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/spawn.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/spawn.hpp
new file mode 100644
index 0000000..078ef88
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/spawn.hpp
@@ -0,0 +1,265 @@
+//
+// spawn.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SPAWN_HPP
+#define ASIO_SPAWN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <boost/coroutine/all.hpp>
+#include "asio/detail/weak_ptr.hpp"
+#include "asio/detail/wrapped_handler.hpp"
+#include "asio/io_service.hpp"
+#include "asio/strand.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// Context object the represents the currently executing coroutine.
+/**
+ * The basic_yield_context class is used to represent the currently executing
+ * stackful coroutine. A basic_yield_context may be passed as a handler to an
+ * asynchronous operation. For example:
+ *
+ * @code template <typename Handler>
+ * void my_coroutine(basic_yield_context<Handler> yield)
+ * {
+ *   ...
+ *   std::size_t n = my_socket.async_read_some(buffer, yield);
+ *   ...
+ * } @endcode
+ *
+ * The initiating function (async_read_some in the above example) suspends the
+ * current coroutine. The coroutine is resumed when the asynchronous operation
+ * completes, and the result of the operation is returned.
+ */
+template <typename Handler>
+class basic_yield_context
+{
+public:
+  /// The coroutine callee type, used by the implementation.
+  /**
+   * When using Boost.Coroutine v1, this type is:
+   * @code typename coroutine<void()> @endcode
+   * When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
+   * @code push_coroutine<void> @endcode
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined callee_type;
+#elif defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
+  typedef boost::coroutines::push_coroutine<void> callee_type;
+#else
+  typedef boost::coroutines::coroutine<void()> callee_type;
+#endif
+  
+  /// The coroutine caller type, used by the implementation.
+  /**
+   * When using Boost.Coroutine v1, this type is:
+   * @code typename coroutine<void()>::caller_type @endcode
+   * When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
+   * @code pull_coroutine<void> @endcode
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined caller_type;
+#elif defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
+  typedef boost::coroutines::pull_coroutine<void> caller_type;
+#else
+  typedef boost::coroutines::coroutine<void()>::caller_type caller_type;
+#endif
+
+  /// Construct a yield context to represent the specified coroutine.
+  /**
+   * Most applications do not need to use this constructor. Instead, the
+   * spawn() function passes a yield context as an argument to the coroutine
+   * function.
+   */
+  basic_yield_context(
+      const detail::weak_ptr<callee_type>& coro,
+      caller_type& ca, Handler& handler)
+    : coro_(coro),
+      ca_(ca),
+      handler_(handler),
+      ec_(0)
+  {
+  }
+
+  /// Return a yield context that sets the specified error_code.
+  /**
+   * By default, when a yield context is used with an asynchronous operation, a
+   * non-success error_code is converted to system_error and thrown. This
+   * operator may be used to specify an error_code object that should instead be
+   * set with the asynchronous operation's result. For example:
+   *
+   * @code template <typename Handler>
+   * void my_coroutine(basic_yield_context<Handler> yield)
+   * {
+   *   ...
+   *   std::size_t n = my_socket.async_read_some(buffer, yield[ec]);
+   *   if (ec)
+   *   {
+   *     // An error occurred.
+   *   }
+   *   ...
+   * } @endcode
+   */
+  basic_yield_context operator[](asio::error_code& ec) const
+  {
+    basic_yield_context tmp(*this);
+    tmp.ec_ = &ec;
+    return tmp;
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+private:
+#endif // defined(GENERATING_DOCUMENTATION)
+  detail::weak_ptr<callee_type> coro_;
+  caller_type& ca_;
+  Handler& handler_;
+  asio::error_code* ec_;
+};
+
+#if defined(GENERATING_DOCUMENTATION)
+/// Context object that represents the currently executing coroutine.
+typedef basic_yield_context<unspecified> yield_context;
+#else // defined(GENERATING_DOCUMENTATION)
+typedef basic_yield_context<
+  detail::wrapped_handler<
+    io_service::strand, void(*)(),
+    detail::is_continuation_if_running> > yield_context;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+/**
+ * @defgroup spawn asio::spawn
+ *
+ * @brief Start a new stackful coroutine.
+ *
+ * The spawn() function is a high-level wrapper over the Boost.Coroutine
+ * library. This function enables programs to implement asynchronous logic in a
+ * synchronous manner, as illustrated by the following example:
+ *
+ * @code asio::spawn(my_strand, do_echo);
+ *
+ * // ...
+ *
+ * void do_echo(asio::yield_context yield)
+ * {
+ *   try
+ *   {
+ *     char data[128];
+ *     for (;;)
+ *     {
+ *       std::size_t length =
+ *         my_socket.async_read_some(
+ *           asio::buffer(data), yield);
+ *
+ *       asio::async_write(my_socket,
+ *           asio::buffer(data, length), yield);
+ *     }
+ *   }
+ *   catch (std::exception& e)
+ *   {
+ *     // ...
+ *   }
+ * } @endcode
+ */
+/*@{*/
+
+/// Start a new stackful coroutine, calling the specified handler when it
+/// completes.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param handler A handler to be called when the coroutine exits. More
+ * importantly, the handler provides an execution context (via the the handler
+ * invocation hook) for the coroutine. The handler must have the signature:
+ * @code void handler(); @endcode
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(basic_yield_context<Handler> yield); @endcode
+ *
+ * @param attributes Boost.Coroutine attributes used to customise the coroutine.
+ */
+template <typename Handler, typename Function>
+void spawn(ASIO_MOVE_ARG(Handler) handler,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes
+      = boost::coroutines::attributes());
+
+/// Start a new stackful coroutine, inheriting the execution context of another.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param ctx Identifies the current coroutine as a parent of the new
+ * coroutine. This specifies that the new coroutine should inherit the
+ * execution context of the parent. For example, if the parent coroutine is
+ * executing in a particular strand, then the new coroutine will execute in the
+ * same strand.
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(basic_yield_context<Handler> yield); @endcode
+ *
+ * @param attributes Boost.Coroutine attributes used to customise the coroutine.
+ */
+template <typename Handler, typename Function>
+void spawn(basic_yield_context<Handler> ctx,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes
+      = boost::coroutines::attributes());
+
+/// Start a new stackful coroutine that executes in the context of a strand.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param strand Identifies a strand. By starting multiple coroutines on the
+ * same strand, the implementation ensures that none of those coroutines can
+ * execute simultaneously.
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(yield_context yield); @endcode
+ *
+ * @param attributes Boost.Coroutine attributes used to customise the coroutine.
+ */
+template <typename Function>
+void spawn(asio::io_service::strand strand,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes
+      = boost::coroutines::attributes());
+
+/// Start a new stackful coroutine that executes on a given io_service.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param io_service Identifies the io_service that will run the coroutine. The
+ * new coroutine is implicitly given its own strand within this io_service.
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(yield_context yield); @endcode
+ *
+ * @param attributes Boost.Coroutine attributes used to customise the coroutine.
+ */
+template <typename Function>
+void spawn(asio::io_service& io_service,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes
+      = boost::coroutines::attributes());
+
+/*@}*/
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/spawn.hpp"
+
+#endif // ASIO_SPAWN_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl.hpp
new file mode 100644
index 0000000..06102fc
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl.hpp
@@ -0,0 +1,30 @@
+//
+// ssl.hpp
+// ~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_HPP
+#define ASIO_SSL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/ssl/basic_context.hpp"
+#include "asio/ssl/context.hpp"
+#include "asio/ssl/context_base.hpp"
+#include "asio/ssl/context_service.hpp"
+#include "asio/ssl/error.hpp"
+#include "asio/ssl/rfc2818_verification.hpp"
+#include "asio/ssl/stream.hpp"
+#include "asio/ssl/stream_base.hpp"
+#include "asio/ssl/stream_service.hpp"
+#include "asio/ssl/verify_context.hpp"
+#include "asio/ssl/verify_mode.hpp"
+
+#endif // ASIO_SSL_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/basic_context.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/basic_context.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/basic_context.hpp
new file mode 100644
index 0000000..17d5380
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/basic_context.hpp
@@ -0,0 +1,40 @@
+//
+// ssl/basic_context.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_BASIC_CONTEXT_HPP
+#define ASIO_SSL_BASIC_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SSL)
+# include "asio/ssl/old/basic_context.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SSL)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+
+#if defined(ASIO_ENABLE_OLD_SSL)
+
+using asio::ssl::old::basic_context;
+
+#endif // defined(ASIO_ENABLE_OLD_SSL)
+
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SSL_BASIC_CONTEXT_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context.hpp
new file mode 100644
index 0000000..87a01e7
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context.hpp
@@ -0,0 +1,787 @@
+//
+// ssl/context.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_CONTEXT_HPP
+#define ASIO_SSL_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SSL)
+# include "asio/ssl/basic_context.hpp"
+# include "asio/ssl/context_service.hpp"
+#else // defined(ASIO_ENABLE_OLD_SSL)
+# include <string>
+# include "asio/buffer.hpp"
+# include "asio/io_service.hpp"
+# include "asio/ssl/context_base.hpp"
+# include "asio/ssl/detail/openssl_types.hpp"
+# include "asio/ssl/detail/openssl_init.hpp"
+# include "asio/ssl/detail/password_callback.hpp"
+# include "asio/ssl/detail/verify_callback.hpp"
+# include "asio/ssl/verify_mode.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SSL)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+
+#if defined(ASIO_ENABLE_OLD_SSL)
+
+/// Typedef for the typical usage of context.
+typedef basic_context<context_service> context;
+
+#else // defined(ASIO_ENABLE_OLD_SSL)
+
+class context
+  : public context_base,
+    private noncopyable
+{
+public:
+  /// The native handle type of the SSL context.
+  typedef SSL_CTX* native_handle_type;
+
+  /// (Deprecated: Use native_handle_type.) The native type of the SSL context.
+  typedef SSL_CTX* impl_type;
+
+  /// Constructor.
+  ASIO_DECL explicit context(method m);
+
+  /// Deprecated constructor taking a reference to an io_service object.
+  ASIO_DECL context(asio::io_service&, method m);
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a context from another.
+  /**
+   * This constructor moves an SSL context from one object to another.
+   *
+   * @param other The other context object from which the move will occur.
+   *
+   * @note Following the move, the following operations only are valid for the
+   * moved-from object:
+   * @li Destruction.
+   * @li As a target for move-assignment.
+   */
+  ASIO_DECL context(context&& other);
+
+  /// Move-assign a context from another.
+  /**
+   * This assignment operator moves an SSL context from one object to another.
+   *
+   * @param other The other context object from which the move will occur.
+   *
+   * @note Following the move, the following operations only are valid for the
+   * moved-from object:
+   * @li Destruction.
+   * @li As a target for move-assignment.
+   */
+  ASIO_DECL context& operator=(context&& other);
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ASIO_DECL ~context();
+
+  /// Get the underlying implementation in the native type.
+  /**
+   * This function may be used to obtain the underlying implementation of the
+   * context. This is intended to allow access to context functionality that is
+   * not otherwise provided.
+   */
+  ASIO_DECL native_handle_type native_handle();
+
+  /// (Deprecated: Use native_handle().) Get the underlying implementation in
+  /// the native type.
+  /**
+   * This function may be used to obtain the underlying implementation of the
+   * context. This is intended to allow access to context functionality that is
+   * not otherwise provided.
+   */
+  ASIO_DECL impl_type impl();
+
+  /// Clear options on the context.
+  /**
+   * This function may be used to configure the SSL options used by the context.
+   *
+   * @param o A bitmask of options. The available option values are defined in
+   * the context_base class. The specified options, if currently enabled on the
+   * context, are cleared.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_clear_options.
+   */
+  ASIO_DECL void clear_options(options o);
+
+  /// Clear options on the context.
+  /**
+   * This function may be used to configure the SSL options used by the context.
+   *
+   * @param o A bitmask of options. The available option values are defined in
+   * the context_base class. The specified options, if currently enabled on the
+   * context, are cleared.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_clear_options.
+   */
+  ASIO_DECL asio::error_code clear_options(options o,
+      asio::error_code& ec);
+
+  /// Set options on the context.
+  /**
+   * This function may be used to configure the SSL options used by the context.
+   *
+   * @param o A bitmask of options. The available option values are defined in
+   * the context_base class. The options are bitwise-ored with any existing
+   * value for the options.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_options.
+   */
+  ASIO_DECL void set_options(options o);
+
+  /// Set options on the context.
+  /**
+   * This function may be used to configure the SSL options used by the context.
+   *
+   * @param o A bitmask of options. The available option values are defined in
+   * the context_base class. The options are bitwise-ored with any existing
+   * value for the options.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_options.
+   */
+  ASIO_DECL asio::error_code set_options(options o,
+      asio::error_code& ec);
+
+  /// Set the peer verification mode.
+  /**
+   * This function may be used to configure the peer verification mode used by
+   * the context.
+   *
+   * @param v A bitmask of peer verification modes. See @ref verify_mode for
+   * available values.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_verify.
+   */
+  ASIO_DECL void set_verify_mode(verify_mode v);
+
+  /// Set the peer verification mode.
+  /**
+   * This function may be used to configure the peer verification mode used by
+   * the context.
+   *
+   * @param v A bitmask of peer verification modes. See @ref verify_mode for
+   * available values.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_verify.
+   */
+  ASIO_DECL asio::error_code set_verify_mode(
+      verify_mode v, asio::error_code& ec);
+
+  /// Set the peer verification depth.
+  /**
+   * This function may be used to configure the maximum verification depth
+   * allowed by the context.
+   *
+   * @param depth Maximum depth for the certificate chain verification that
+   * shall be allowed.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_verify_depth.
+   */
+  ASIO_DECL void set_verify_depth(int depth);
+
+  /// Set the peer verification depth.
+  /**
+   * This function may be used to configure the maximum verification depth
+   * allowed by the context.
+   *
+   * @param depth Maximum depth for the certificate chain verification that
+   * shall be allowed.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_verify_depth.
+   */
+  ASIO_DECL asio::error_code set_verify_depth(
+      int depth, asio::error_code& ec);
+
+  /// Set the callback used to verify peer certificates.
+  /**
+   * This function is used to specify a callback function that will be called
+   * by the implementation when it needs to verify a peer certificate.
+   *
+   * @param callback The function object to be used for verifying a certificate.
+   * The function signature of the handler must be:
+   * @code bool verify_callback(
+   *   bool preverified, // True if the certificate passed pre-verification.
+   *   verify_context& ctx // The peer certificate and other context.
+   * ); @endcode
+   * The return value of the callback is true if the certificate has passed
+   * verification, false otherwise.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_verify.
+   */
+  template <typename VerifyCallback>
+  void set_verify_callback(VerifyCallback callback);
+
+  /// Set the callback used to verify peer certificates.
+  /**
+   * This function is used to specify a callback function that will be called
+   * by the implementation when it needs to verify a peer certificate.
+   *
+   * @param callback The function object to be used for verifying a certificate.
+   * The function signature of the handler must be:
+   * @code bool verify_callback(
+   *   bool preverified, // True if the certificate passed pre-verification.
+   *   verify_context& ctx // The peer certificate and other context.
+   * ); @endcode
+   * The return value of the callback is true if the certificate has passed
+   * verification, false otherwise.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_verify.
+   */
+  template <typename VerifyCallback>
+  asio::error_code set_verify_callback(VerifyCallback callback,
+      asio::error_code& ec);
+
+  /// Load a certification authority file for performing verification.
+  /**
+   * This function is used to load one or more trusted certification authorities
+   * from a file.
+   *
+   * @param filename The name of a file containing certification authority
+   * certificates in PEM format.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_load_verify_locations.
+   */
+  ASIO_DECL void load_verify_file(const std::string& filename);
+
+  /// Load a certification authority file for performing verification.
+  /**
+   * This function is used to load the certificates for one or more trusted
+   * certification authorities from a file.
+   *
+   * @param filename The name of a file containing certification authority
+   * certificates in PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_load_verify_locations.
+   */
+  ASIO_DECL asio::error_code load_verify_file(
+      const std::string& filename, asio::error_code& ec);
+
+  /// Add certification authority for performing verification.
+  /**
+   * This function is used to add one trusted certification authority
+   * from a memory buffer.
+   *
+   * @param ca The buffer containing the certification authority certificate.
+   * The certificate must use the PEM format.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_get_cert_store and @c X509_STORE_add_cert.
+   */
+  ASIO_DECL void add_certificate_authority(const const_buffer& ca);
+
+  /// Add certification authority for performing verification.
+  /**
+   * This function is used to add one trusted certification authority
+   * from a memory buffer.
+   *
+   * @param ca The buffer containing the certification authority certificate.
+   * The certificate must use the PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_get_cert_store and @c X509_STORE_add_cert.
+   */
+  ASIO_DECL asio::error_code add_certificate_authority(
+      const const_buffer& ca, asio::error_code& ec);
+
+  /// Configures the context to use the default directories for finding
+  /// certification authority certificates.
+  /**
+   * This function specifies that the context should use the default,
+   * system-dependent directories for locating certification authority
+   * certificates.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_default_verify_paths.
+   */
+  ASIO_DECL void set_default_verify_paths();
+
+  /// Configures the context to use the default directories for finding
+  /// certification authority certificates.
+  /**
+   * This function specifies that the context should use the default,
+   * system-dependent directories for locating certification authority
+   * certificates.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_default_verify_paths.
+   */
+  ASIO_DECL asio::error_code set_default_verify_paths(
+      asio::error_code& ec);
+
+  /// Add a directory containing certificate authority files to be used for
+  /// performing verification.
+  /**
+   * This function is used to specify the name of a directory containing
+   * certification authority certificates. Each file in the directory must
+   * contain a single certificate. The files must be named using the subject
+   * name's hash and an extension of ".0".
+   *
+   * @param path The name of a directory containing the certificates.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_load_verify_locations.
+   */
+  ASIO_DECL void add_verify_path(const std::string& path);
+
+  /// Add a directory containing certificate authority files to be used for
+  /// performing verification.
+  /**
+   * This function is used to specify the name of a directory containing
+   * certification authority certificates. Each file in the directory must
+   * contain a single certificate. The files must be named using the subject
+   * name's hash and an extension of ".0".
+   *
+   * @param path The name of a directory containing the certificates.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_load_verify_locations.
+   */
+  ASIO_DECL asio::error_code add_verify_path(
+      const std::string& path, asio::error_code& ec);
+
+  /// Use a certificate from a memory buffer.
+  /**
+   * This function is used to load a certificate into the context from a buffer.
+   *
+   * @param certificate The buffer containing the certificate.
+   *
+   * @param format The certificate format (ASN.1 or PEM).
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_certificate or SSL_CTX_use_certificate_ASN1.
+   */
+  ASIO_DECL void use_certificate(
+      const const_buffer& certificate, file_format format);
+
+  /// Use a certificate from a memory buffer.
+  /**
+   * This function is used to load a certificate into the context from a buffer.
+   *
+   * @param certificate The buffer containing the certificate.
+   *
+   * @param format The certificate format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_certificate or SSL_CTX_use_certificate_ASN1.
+   */
+  ASIO_DECL asio::error_code use_certificate(
+      const const_buffer& certificate, file_format format,
+      asio::error_code& ec);
+
+  /// Use a certificate from a file.
+  /**
+   * This function is used to load a certificate into the context from a file.
+   *
+   * @param filename The name of the file containing the certificate.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_certificate_file.
+   */
+  ASIO_DECL void use_certificate_file(
+      const std::string& filename, file_format format);
+
+  /// Use a certificate from a file.
+  /**
+   * This function is used to load a certificate into the context from a file.
+   *
+   * @param filename The name of the file containing the certificate.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_certificate_file.
+   */
+  ASIO_DECL asio::error_code use_certificate_file(
+      const std::string& filename, file_format format,
+      asio::error_code& ec);
+
+  /// Use a certificate chain from a memory buffer.
+  /**
+   * This function is used to load a certificate chain into the context from a
+   * buffer.
+   *
+   * @param chain The buffer containing the certificate chain. The certificate
+   * chain must use the PEM format.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_certificate and SSL_CTX_add_extra_chain_cert.
+   */
+  ASIO_DECL void use_certificate_chain(const const_buffer& chain);
+
+  /// Use a certificate chain from a memory buffer.
+  /**
+   * This function is used to load a certificate chain into the context from a
+   * buffer.
+   *
+   * @param chain The buffer containing the certificate chain. The certificate
+   * chain must use the PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_certificate and SSL_CTX_add_extra_chain_cert.
+   */
+  ASIO_DECL asio::error_code use_certificate_chain(
+      const const_buffer& chain, asio::error_code& ec);
+
+  /// Use a certificate chain from a file.
+  /**
+   * This function is used to load a certificate chain into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the certificate. The file
+   * must use the PEM format.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_certificate_chain_file.
+   */
+  ASIO_DECL void use_certificate_chain_file(const std::string& filename);
+
+  /// Use a certificate chain from a file.
+  /**
+   * This function is used to load a certificate chain into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the certificate. The file
+   * must use the PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_certificate_chain_file.
+   */
+  ASIO_DECL asio::error_code use_certificate_chain_file(
+      const std::string& filename, asio::error_code& ec);
+
+  /// Use a private key from a memory buffer.
+  /**
+   * This function is used to load a private key into the context from a buffer.
+   *
+   * @param private_key The buffer containing the private key.
+   *
+   * @param format The private key format (ASN.1 or PEM).
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_PrivateKey or SSL_CTX_use_PrivateKey_ASN1.
+   */
+  ASIO_DECL void use_private_key(
+      const const_buffer& private_key, file_format format);
+
+  /// Use a private key from a memory buffer.
+  /**
+   * This function is used to load a private key into the context from a buffer.
+   *
+   * @param private_key The buffer containing the private key.
+   *
+   * @param format The private key format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_PrivateKey or SSL_CTX_use_PrivateKey_ASN1.
+   */
+  ASIO_DECL asio::error_code use_private_key(
+      const const_buffer& private_key, file_format format,
+      asio::error_code& ec);
+
+  /// Use a private key from a file.
+  /**
+   * This function is used to load a private key into the context from a file.
+   *
+   * @param filename The name of the file containing the private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_PrivateKey_file.
+   */
+  ASIO_DECL void use_private_key_file(
+      const std::string& filename, file_format format);
+
+  /// Use a private key from a file.
+  /**
+   * This function is used to load a private key into the context from a file.
+   *
+   * @param filename The name of the file containing the private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_PrivateKey_file.
+   */
+  ASIO_DECL asio::error_code use_private_key_file(
+      const std::string& filename, file_format format,
+      asio::error_code& ec);
+
+  /// Use an RSA private key from a memory buffer.
+  /**
+   * This function is used to load an RSA private key into the context from a
+   * buffer.
+   *
+   * @param private_key The buffer containing the RSA private key.
+   *
+   * @param format The private key format (ASN.1 or PEM).
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_RSAPrivateKey or SSL_CTX_use_RSAPrivateKey_ASN1.
+   */
+  ASIO_DECL void use_rsa_private_key(
+      const const_buffer& private_key, file_format format);
+
+  /// Use an RSA private key from a memory buffer.
+  /**
+   * This function is used to load an RSA private key into the context from a
+   * buffer.
+   *
+   * @param private_key The buffer containing the RSA private key.
+   *
+   * @param format The private key format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_RSAPrivateKey or SSL_CTX_use_RSAPrivateKey_ASN1.
+   */
+  ASIO_DECL asio::error_code use_rsa_private_key(
+      const const_buffer& private_key, file_format format,
+      asio::error_code& ec);
+
+  /// Use an RSA private key from a file.
+  /**
+   * This function is used to load an RSA private key into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the RSA private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_use_RSAPrivateKey_file.
+   */
+  ASIO_DECL void use_rsa_private_key_file(
+      const std::string& filename, file_format format);
+
+  /// Use an RSA private key from a file.
+  /**
+   * This function is used to load an RSA private key into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the RSA private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_use_RSAPrivateKey_file.
+   */
+  ASIO_DECL asio::error_code use_rsa_private_key_file(
+      const std::string& filename, file_format format,
+      asio::error_code& ec);
+
+  /// Use the specified memory buffer to obtain the temporary Diffie-Hellman
+  /// parameters.
+  /**
+   * This function is used to load Diffie-Hellman parameters into the context
+   * from a buffer.
+   *
+   * @param dh The memory buffer containing the Diffie-Hellman parameters. The
+   * buffer must use the PEM format.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_tmp_dh.
+   */
+  ASIO_DECL void use_tmp_dh(const const_buffer& dh);
+
+  /// Use the specified memory buffer to obtain the temporary Diffie-Hellman
+  /// parameters.
+  /**
+   * This function is used to load Diffie-Hellman parameters into the context
+   * from a buffer.
+   *
+   * @param dh The memory buffer containing the Diffie-Hellman parameters. The
+   * buffer must use the PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_tmp_dh.
+   */
+  ASIO_DECL asio::error_code use_tmp_dh(
+      const const_buffer& dh, asio::error_code& ec);
+
+  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
+  /**
+   * This function is used to load Diffie-Hellman parameters into the context
+   * from a file.
+   *
+   * @param filename The name of the file containing the Diffie-Hellman
+   * parameters. The file must use the PEM format.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_tmp_dh.
+   */
+  ASIO_DECL void use_tmp_dh_file(const std::string& filename);
+
+  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
+  /**
+   * This function is used to load Diffie-Hellman parameters into the context
+   * from a file.
+   *
+   * @param filename The name of the file containing the Diffie-Hellman
+   * parameters. The file must use the PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_tmp_dh.
+   */
+  ASIO_DECL asio::error_code use_tmp_dh_file(
+      const std::string& filename, asio::error_code& ec);
+
+  /// Set the password callback.
+  /**
+   * This function is used to specify a callback function to obtain password
+   * information about an encrypted key in PEM format.
+   *
+   * @param callback The function object to be used for obtaining the password.
+   * The function signature of the handler must be:
+   * @code std::string password_callback(
+   *   std::size_t max_length,  // The maximum size for a password.
+   *   password_purpose purpose // Whether password is for reading or writing.
+   * ); @endcode
+   * The return value of the callback is a string containing the password.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note Calls @c SSL_CTX_set_default_passwd_cb.
+   */
+  template <typename PasswordCallback>
+  void set_password_callback(PasswordCallback callback);
+
+  /// Set the password callback.
+  /**
+   * This function is used to specify a callback function to obtain password
+   * information about an encrypted key in PEM format.
+   *
+   * @param callback The function object to be used for obtaining the password.
+   * The function signature of the handler must be:
+   * @code std::string password_callback(
+   *   std::size_t max_length,  // The maximum size for a password.
+   *   password_purpose purpose // Whether password is for reading or writing.
+   * ); @endcode
+   * The return value of the callback is a string containing the password.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls @c SSL_CTX_set_default_passwd_cb.
+   */
+  template <typename PasswordCallback>
+  asio::error_code set_password_callback(PasswordCallback callback,
+      asio::error_code& ec);
+
+private:
+  struct bio_cleanup;
+  struct x509_cleanup;
+  struct evp_pkey_cleanup;
+  struct rsa_cleanup;
+  struct dh_cleanup;
+
+  // Helper function used to set a peer certificate verification callback.
+  ASIO_DECL asio::error_code do_set_verify_callback(
+      detail::verify_callback_base* callback, asio::error_code& ec);
+
+  // Callback used when the SSL implementation wants to verify a certificate.
+  ASIO_DECL static int verify_callback_function(
+      int preverified, X509_STORE_CTX* ctx);
+
+  // Helper function used to set a password callback.
+  ASIO_DECL asio::error_code do_set_password_callback(
+      detail::password_callback_base* callback, asio::error_code& ec);
+
+  // Callback used when the SSL implementation wants a password.
+  ASIO_DECL static int password_callback_function(
+      char* buf, int size, int purpose, void* data);
+
+  // Helper function to set the temporary Diffie-Hellman parameters from a BIO.
+  ASIO_DECL asio::error_code do_use_tmp_dh(
+      BIO* bio, asio::error_code& ec);
+
+  // Helper function to make a BIO from a memory buffer.
+  ASIO_DECL BIO* make_buffer_bio(const const_buffer& b);
+
+  // The underlying native implementation.
+  native_handle_type handle_;
+
+  // Ensure openssl is initialised.
+  asio::ssl::detail::openssl_init<> init_;
+};
+
+#endif // defined(ASIO_ENABLE_OLD_SSL)
+
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/ssl/impl/context.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/ssl/impl/context.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_SSL_CONTEXT_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_base.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_base.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_base.hpp
new file mode 100644
index 0000000..3fc400e
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_base.hpp
@@ -0,0 +1,167 @@
+//
+// ssl/context_base.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_CONTEXT_BASE_HPP
+#define ASIO_SSL_CONTEXT_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+
+/// The context_base class is used as a base for the basic_context class
+/// template so that we have a common place to define various enums.
+class context_base
+{
+public:
+  /// Different methods supported by a context.
+  enum method
+  {
+    /// Generic SSL version 2.
+    sslv2,
+
+    /// SSL version 2 client.
+    sslv2_client,
+
+    /// SSL version 2 server.
+    sslv2_server,
+
+    /// Generic SSL version 3.
+    sslv3,
+
+    /// SSL version 3 client.
+    sslv3_client,
+
+    /// SSL version 3 server.
+    sslv3_server,
+
+    /// Generic TLS version 1.
+    tlsv1,
+
+    /// TLS version 1 client.
+    tlsv1_client,
+
+    /// TLS version 1 server.
+    tlsv1_server,
+
+    /// Generic SSL/TLS.
+    sslv23,
+
+    /// SSL/TLS client.
+    sslv23_client,
+
+    /// SSL/TLS server.
+    sslv23_server,
+
+    /// Generic TLS version 1.1.
+    tlsv11,
+
+    /// TLS version 1.1 client.
+    tlsv11_client,
+
+    /// TLS version 1.1 server.
+    tlsv11_server,
+
+    /// Generic TLS version 1.2.
+    tlsv12,
+
+    /// TLS version 1.2 client.
+    tlsv12_client,
+
+    /// TLS version 1.2 server.
+    tlsv12_server
+  };
+
+  /// Bitmask type for SSL options.
+  typedef long options;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// Implement various bug workarounds.
+  static const long default_workarounds = implementation_defined;
+
+  /// Always create a new key when using tmp_dh parameters.
+  static const long single_dh_use = implementation_defined;
+
+  /// Disable SSL v2.
+  static const long no_sslv2 = implementation_defined;
+
+  /// Disable SSL v3.
+  static const long no_sslv3 = implementation_defined;
+
+  /// Disable TLS v1.
+  static const long no_tlsv1 = implementation_defined;
+
+  /// Disable compression. Compression is disabled by default.
+  static const long no_compression = implementation_defined;
+#else
+  ASIO_STATIC_CONSTANT(long, default_workarounds = SSL_OP_ALL);
+  ASIO_STATIC_CONSTANT(long, single_dh_use = SSL_OP_SINGLE_DH_USE);
+  ASIO_STATIC_CONSTANT(long, no_sslv2 = SSL_OP_NO_SSLv2);
+  ASIO_STATIC_CONSTANT(long, no_sslv3 = SSL_OP_NO_SSLv3);
+  ASIO_STATIC_CONSTANT(long, no_tlsv1 = SSL_OP_NO_TLSv1);
+# if defined(SSL_OP_NO_COMPRESSION)
+  ASIO_STATIC_CONSTANT(long, no_compression = SSL_OP_NO_COMPRESSION);
+# else // defined(SSL_OP_NO_COMPRESSION)
+  ASIO_STATIC_CONSTANT(long, no_compression = 0x20000L);
+# endif // defined(SSL_OP_NO_COMPRESSION)
+#endif
+
+  /// File format types.
+  enum file_format
+  {
+    /// ASN.1 file.
+    asn1,
+
+    /// PEM file.
+    pem
+  };
+
+#if !defined(GENERATING_DOCUMENTATION)
+  // The following types and constants are preserved for backward compatibility.
+  // New programs should use the equivalents of the same names that are defined
+  // in the asio::ssl namespace.
+  typedef int verify_mode;
+  ASIO_STATIC_CONSTANT(int, verify_none = SSL_VERIFY_NONE);
+  ASIO_STATIC_CONSTANT(int, verify_peer = SSL_VERIFY_PEER);
+  ASIO_STATIC_CONSTANT(int,
+      verify_fail_if_no_peer_cert = SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
+  ASIO_STATIC_CONSTANT(int, verify_client_once = SSL_VERIFY_CLIENT_ONCE);
+#endif
+
+  /// Purpose of PEM password.
+  enum password_purpose
+  {
+    /// The password is needed for reading/decryption.
+    for_reading,
+
+    /// The password is needed for writing/encryption.
+    for_writing
+  };
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~context_base()
+  {
+  }
+};
+
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SSL_CONTEXT_BASE_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_service.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_service.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_service.hpp
new file mode 100644
index 0000000..af293a1
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/context_service.hpp
@@ -0,0 +1,40 @@
+//
+// ssl/context_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_CONTEXT_SERVICE_HPP
+#define ASIO_SSL_CONTEXT_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+  
+#if defined(ASIO_ENABLE_OLD_SSL)
+# include "asio/ssl/old/context_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SSL)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+
+#if defined(ASIO_ENABLE_OLD_SSL)
+
+using asio::ssl::old::context_service;
+
+#endif // defined(ASIO_ENABLE_OLD_SSL)
+
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SSL_CONTEXT_SERVICE_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/buffered_handshake_op.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/buffered_handshake_op.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/buffered_handshake_op.hpp
new file mode 100644
index 0000000..aed99dd
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/buffered_handshake_op.hpp
@@ -0,0 +1,110 @@
+//
+// ssl/detail/buffered_handshake_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
+#define ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+# include "asio/ssl/detail/engine.hpp"
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+namespace detail {
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+
+template <typename ConstBufferSequence>
+class buffered_handshake_op
+{
+public:
+  buffered_handshake_op(stream_base::handshake_type type,
+      const ConstBufferSequence& buffers)
+    : type_(type),
+      buffers_(buffers),
+      total_buffer_size_(asio::buffer_size(buffers_))
+  {
+  }
+
+  engine::want operator()(engine& eng,
+      asio::error_code& ec,
+      std::size_t& bytes_transferred) const
+  {
+    typename ConstBufferSequence::const_iterator iter = buffers_.begin();
+    typename ConstBufferSequence::const_iterator end = buffers_.end();
+    std::size_t accumulated_size = 0;
+
+    for (;;)
+    {
+      engine::want want = eng.handshake(type_, ec);
+      if (want != engine::want_input_and_retry
+          || bytes_transferred == total_buffer_size_)
+        return want;
+
+      // Find the next buffer piece to be fed to the engine.
+      while (iter != end)
+      {
+        const_buffer buffer(*iter);
+
+        // Skip over any buffers which have already been consumed by the engine.
+        if (bytes_transferred >= accumulated_size + buffer_size(buffer))
+        {
+          accumulated_size += buffer_size(buffer);
+          ++iter;
+          continue;
+        }
+
+        // The current buffer may have been partially consumed by the engine on
+        // a previous iteration. If so, adjust the buffer to point to the
+        // unused portion.
+        if (bytes_transferred > accumulated_size)
+          buffer = buffer + (bytes_transferred - accumulated_size);
+
+        // Pass the buffer to the engine, and update the bytes transferred to
+        // reflect the total number of bytes consumed so far.
+        bytes_transferred += buffer_size(buffer);
+        buffer = eng.put_input(buffer);
+        bytes_transferred -= buffer_size(buffer);
+        break;
+      }
+    }
+  }
+
+  template <typename Handler>
+  void call_handler(Handler& handler,
+      const asio::error_code& ec,
+      const std::size_t& bytes_transferred) const
+  {
+    handler(ec, bytes_transferred);
+  }
+
+private:
+  stream_base::handshake_type type_;
+  ConstBufferSequence buffers_;
+  std::size_t total_buffer_size_;
+};
+
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/engine.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/engine.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/engine.hpp
new file mode 100644
index 0000000..9bb42b6
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/engine.hpp
@@ -0,0 +1,164 @@
+//
+// ssl/detail/engine.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_DETAIL_ENGINE_HPP
+#define ASIO_SSL_DETAIL_ENGINE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+# include "asio/buffer.hpp"
+# include "asio/detail/static_mutex.hpp"
+# include "asio/ssl/detail/openssl_types.hpp"
+# include "asio/ssl/detail/verify_callback.hpp"
+# include "asio/ssl/stream_base.hpp"
+# include "asio/ssl/verify_mode.hpp"
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+namespace detail {
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+
+class engine
+{
+public:
+  enum want
+  {
+    // Returned by functions to indicate that the engine wants input. The input
+    // buffer should be updated to point to the data. The engine then needs to
+    // be called again to retry the operation.
+    want_input_and_retry = -2,
+
+    // Returned by functions to indicate that the engine wants to write output.
+    // The output buffer points to the data to be written. The engine then
+    // needs to be called again to retry the operation.
+    want_output_and_retry = -1,
+
+    // Returned by functions to indicate that the engine doesn't need input or
+    // output.
+    want_nothing = 0,
+
+    // Returned by functions to indicate that the engine wants to write output.
+    // The output buffer points to the data to be written. After that the
+    // operation is complete, and the engine does not need to be called again.
+    want_output = 1
+  };
+
+  // Construct a new engine for the specified context.
+  ASIO_DECL explicit engine(SSL_CTX* context);
+
+  // Destructor.
+  ASIO_DECL ~engine();
+
+  // Get the underlying implementation in the native type.
+  ASIO_DECL SSL* native_handle();
+
+  // Set the peer verification mode.
+  ASIO_DECL asio::error_code set_verify_mode(
+      verify_mode v, asio::error_code& ec);
+
+  // Set the peer verification depth.
+  ASIO_DECL asio::error_code set_verify_depth(
+      int depth, asio::error_code& ec);
+
+  // Set a peer certificate verification callback.
+  ASIO_DECL asio::error_code set_verify_callback(
+      verify_callback_base* callback, asio::error_code& ec);
+
+  // Perform an SSL handshake using either SSL_connect (client-side) or
+  // SSL_accept (server-side).
+  ASIO_DECL want handshake(
+      stream_base::handshake_type type, asio::error_code& ec);
+
+  // Perform a graceful shutdown of the SSL session.
+  ASIO_DECL want shutdown(asio::error_code& ec);
+
+  // Write bytes to the SSL session.
+  ASIO_DECL want write(const asio::const_buffer& data,
+      asio::error_code& ec, std::size_t& bytes_transferred);
+
+  // Read bytes from the SSL session.
+  ASIO_DECL want read(const asio::mutable_buffer& data,
+      asio::error_code& ec, std::size_t& bytes_transferred);
+
+  // Get output data to be written to the transport.
+  ASIO_DECL asio::mutable_buffers_1 get_output(
+      const asio::mutable_buffer& data);
+
+  // Put input data that was read from the transport.
+  ASIO_DECL asio::const_buffer put_input(
+      const asio::const_buffer& data);
+
+  // Map an error::eof code returned by the underlying transport according to
+  // the type and state of the SSL session. Returns a const reference to the
+  // error code object, suitable for passing to a completion handler.
+  ASIO_DECL const asio::error_code& map_error_code(
+      asio::error_code& ec) const;
+
+private:
+  // Disallow copying and assignment.
+  engine(const engine&);
+  engine& operator=(const engine&);
+
+  // Callback used when the SSL implementation wants to verify a certificate.
+  ASIO_DECL static int verify_callback_function(
+      int preverified, X509_STORE_CTX* ctx);
+
+  // The SSL_accept function may not be thread safe. This mutex is used to
+  // protect all calls to the SSL_accept function.
+  ASIO_DECL static asio::detail::static_mutex& accept_mutex();
+
+  // Perform one operation. Returns >= 0 on success or error, want_read if the
+  // operation needs more input, or want_write if it needs to write some output
+  // before the operation can complete.
+  ASIO_DECL want perform(int (engine::* op)(void*, std::size_t),
+      void* data, std::size_t length, asio::error_code& ec,
+      std::size_t* bytes_transferred);
+
+  // Adapt the SSL_accept function to the signature needed for perform().
+  ASIO_DECL int do_accept(void*, std::size_t);
+
+  // Adapt the SSL_connect function to the signature needed for perform().
+  ASIO_DECL int do_connect(void*, std::size_t);
+
+  // Adapt the SSL_shutdown function to the signature needed for perform().
+  ASIO_DECL int do_shutdown(void*, std::size_t);
+
+  // Adapt the SSL_read function to the signature needed for perform().
+  ASIO_DECL int do_read(void* data, std::size_t length);
+
+  // Adapt the SSL_write function to the signature needed for perform().
+  ASIO_DECL int do_write(void* data, std::size_t length);
+
+  SSL* ssl_;
+  BIO* ext_bio_;
+};
+
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/ssl/detail/impl/engine.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_SSL_DETAIL_ENGINE_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/handshake_op.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/handshake_op.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/handshake_op.hpp
new file mode 100644
index 0000000..25c110f
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/handshake_op.hpp
@@ -0,0 +1,68 @@
+//
+// ssl/detail/handshake_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
+#define ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+# include "asio/ssl/detail/engine.hpp"
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+namespace detail {
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+
+class handshake_op
+{
+public:
+  handshake_op(stream_base::handshake_type type)
+    : type_(type)
+  {
+  }
+
+  engine::want operator()(engine& eng,
+      asio::error_code& ec,
+      std::size_t& bytes_transferred) const
+  {
+    bytes_transferred = 0;
+    return eng.handshake(type_, ec);
+  }
+
+  template <typename Handler>
+  void call_handler(Handler& handler,
+      const asio::error_code& ec,
+      const std::size_t&) const
+  {
+    handler(ec);
+  }
+
+private:
+  stream_base::handshake_type type_;
+};
+
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/engine.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/engine.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/engine.ipp
new file mode 100644
index 0000000..59f8283
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/engine.ipp
@@ -0,0 +1,326 @@
+//
+// ssl/detail/impl/engine.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
+#define ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+# include "asio/detail/throw_error.hpp"
+# include "asio/error.hpp"
+# include "asio/ssl/detail/engine.hpp"
+# include "asio/ssl/error.hpp"
+# include "asio/ssl/verify_context.hpp"
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+namespace detail {
+
+#if !defined(ASIO_ENABLE_OLD_SSL)
+
+engine::engine(SSL_CTX* context)
+  : ssl_(::SSL_new(context))
+{
+  if (!ssl_)
+  {
+    asio::error_code ec(
+        static_cast<int>(::ERR_get_error()),
+        asio::error::get_ssl_category());
+    asio::detail::throw_error(ec, "engine");
+  }
+
+  accept_mutex().init();
+
+  ::SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE);
+  ::SSL_set_mode(ssl_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
+#if defined(SSL_MODE_RELEASE_BUFFERS)
+  ::SSL_set_mode(ssl_, SSL_MODE_RELEASE_BUFFERS);
+#endif // defined(SSL_MODE_RELEASE_BUFFERS)
+
+  ::BIO* int_bio = 0;
+  ::BIO_new_bio_pair(&int_bio, 0, &ext_bio_, 0);
+  ::SSL_set_bio(ssl_, int_bio, int_bio);
+}
+
+engine::~engine()
+{
+  if (SSL_get_app_data(ssl_))
+  {
+    delete static_cast<verify_callback_base*>(SSL_get_app_data(ssl_));
+    SSL_set_app_data(ssl_, 0);
+  }
+
+  ::BIO_free(ext_bio_);
+  ::SSL_free(ssl_);
+}
+
+SSL* engine::native_handle()
+{
+  return ssl_;
+}
+
+asio::error_code engine::set_verify_mode(
+    verify_mode v, asio::error_code& ec)
+{
+  ::SSL_set_verify(ssl_, v, ::SSL_get_verify_callback(ssl_));
+
+  ec = asio::error_code();
+  return ec;
+}
+
+asio::error_code engine::set_verify_depth(
+    int depth, asio::error_code& ec)
+{
+  ::SSL_set_verify_depth(ssl_, depth);
+
+  ec = asio::error_code();
+  return ec;
+}
+
+asio::error_code engine::set_verify_callback(
+    verify_callback_base* callback, asio::error_code& ec)
+{
+  if (SSL_get_app_data(ssl_))
+    delete static_cast<verify_callback_base*>(SSL_get_app_data(ssl_));
+
+  SSL_set_app_data(ssl_, callback);
+
+  ::SSL_set_verify(ssl_, ::SSL_get_verify_mode(ssl_),
+      &engine::verify_callback_function);
+
+  ec = asio::error_code();
+  return ec;
+}
+
+int engine::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
+{
+  if (ctx)
+  {
+    if (SSL* ssl = static_cast<SSL*>(
+          ::X509_STORE_CTX_get_ex_data(
+            ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))
+    {
+      if (SSL_get_app_data(ssl))
+      {
+        verify_callback_base* callback =
+          static_cast<verify_callback_base*>(
+              SSL_get_app_data(ssl));
+
+        verify_context verify_ctx(ctx);
+        return callback->call(preverified != 0, verify_ctx) ? 1 : 0;
+      }
+    }
+  }
+
+  return 0;
+}
+
+engine::want engine::handshake(
+    stream_base::handshake_type type, asio::error_code& ec)
+{
+  return perform((type == asio::ssl::stream_base::client)
+      ? &engine::do_connect : &engine::do_accept, 0, 0, ec, 0);
+}
+
+engine::want engine::shutdown(asio::error_code& ec)
+{
+  return perform(&engine::do_shutdown, 0, 0, ec, 0);
+}
+
+engine::want engine::write(const asio::const_buffer& data,
+    asio::error_code& ec, std::size_t& bytes_transferred)
+{
+  if (asio::buffer_size(data) == 0)
+  {
+    ec = asio::error_code();
+    return engine::want_nothing;
+  }
+
+  return perform(&engine::do_write,
+      const_cast<void*>(asio::buffer_cast<const void*>(data)),
+      asio::buffer_size(data), ec, &bytes_transferred);
+}
+
+engine::want engine::read(const asio::mutable_buffer& data,
+    asio::error_code& ec, std::size_t& bytes_transferred)
+{
+  if (asio::buffer_size(data) == 0)
+  {
+    ec = asio::error_code();
+    return engine::want_nothing;
+  }
+
+  return perform(&engine::do_read,
+      asio::buffer_cast<void*>(data),
+      asio::buffer_size(data), ec, &bytes_transferred);
+}
+
+asio::mutable_buffers_1 engine::get_output(
+    const asio::mutable_buffer& data)
+{
+  int length = ::BIO_read(ext_bio_,
+      asio::buffer_cast<void*>(data),
+      static_cast<int>(asio::buffer_size(data)));
+
+  return asio::buffer(data,
+      length > 0 ? static_cast<std::size_t>(length) : 0);
+}
+
+asio::const_buffer engine::put_input(
+    const asio::const_buffer& data)
+{
+  int length = ::BIO_write(ext_bio_,
+      asio::buffer_cast<const void*>(data),
+      static_cast<int>(asio::buffer_size(data)));
+
+  return asio::buffer(data +
+      (length > 0 ? static_cast<std::size_t>(length) : 0));
+}
+
+const asio::error_code& engine::map_error_code(
+    asio::error_code& ec) const
+{
+  // We only want to map the error::eof code.
+  if (ec != asio::error::eof)
+    return ec;
+
+  // If there's data yet to be read, it's an error.
+  if (BIO_wpending(ext_bio_))
+  {
+    ec = asio::error_code(
+        ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ),
+        asio::error::get_ssl_category());
+    return ec;
+  }
+
+  // SSL v2 doesn't provide a protocol-level shutdown, so an eof on the
+  // underlying transport is passed through.
+  if (ssl_ && ssl_->version == SSL2_VERSION)
+    return ec;
+
+  // Otherwise, the peer should have negotiated a proper shutdown.
+  if ((::SSL_get_shutdown(ssl_) & SSL_RECEIVED_SHUTDOWN) == 0)
+  {
+    ec = asio::error_code(
+        ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ),
+        asio::error::get_ssl_category());
+  }
+
+  return ec;
+}
+
+asio::detail::static_mutex& engine::accept_mutex()
+{
+  static asio::detail::static_mutex mutex = ASIO_STATIC_MUTEX_INIT;
+  return mutex;
+}
+
+engine::want engine::perform(int (engine::* op)(void*, std::size_t),
+    void* data, std::size_t length, asio::error_code& ec,
+    std::size_t* bytes_transferred)
+{
+  std::size_t pending_output_before = ::BIO_ctrl_pending(ext_bio_);
+  int result = (this->*op)(data, length);
+  int ssl_error = ::SSL_get_error(ssl_, result);
+  int sys_error = static_cast<int>(::ERR_get_error());
+  std::size_t pending_output_after = ::BIO_ctrl_pending(ext_bio_);
+
+  if (ssl_error == SSL_ERROR_SSL)
+  {
+    ec = asio::error_code(sys_error,
+        asio::error::get_ssl_category());
+    return want_nothing;
+  }
+
+  if (ssl_error == SSL_ERROR_SYSCALL)
+  {
+    ec = asio::error_code(sys_error,
+        asio::error::get_system_category());
+    return want_nothing;
+  }
+
+  if (result > 0 && bytes_transferred)
+    *bytes_transferred = static_cast<std::size_t>(result);
+
+  if (ssl_error == SSL_ERROR_WANT_WRITE)
+  {
+    ec = asio::error_code();
+    return want_output_and_retry;
+  }
+  else if (pending_output_after > pending_output_before)
+  {
+    ec = asio::error_code();
+    return result > 0 ? want_output : want_output_and_retry;
+  }
+  else if (ssl_error == SSL_ERROR_WANT_READ)
+  {
+    ec = asio::error_code();
+    return want_input_and_retry;
+  }
+  else if (::SSL_get_shutdown(ssl_) & SSL_RECEIVED_SHUTDOWN)
+  {
+    ec = asio::error::eof;
+    return want_nothing;
+  }
+  else
+  {
+    ec = asio::error_code();
+    return want_nothing;
+  }
+}
+
+int engine::do_accept(void*, std::size_t)
+{
+  asio::detail::static_mutex::scoped_lock lock(accept_mutex());
+  return ::SSL_accept(ssl_);
+}
+
+int engine::do_connect(void*, std::size_t)
+{
+  return ::SSL_connect(ssl_);
+}
+
+int engine::do_shutdown(void*, std::size_t)
+{
+  int result = ::SSL_shutdown(ssl_);
+  if (result == 0)
+    result = ::SSL_shutdown(ssl_);
+  return result;
+}
+
+int engine::do_read(void* data, std::size_t length)
+{
+  return ::SSL_read(ssl_, data,
+      length < INT_MAX ? static_cast<int>(length) : INT_MAX);
+}
+
+int engine::do_write(void* data, std::size_t length)
+{
+  return ::SSL_write(ssl_, data,
+      length < INT_MAX ? static_cast<int>(length) : INT_MAX);
+}
+
+#endif // !defined(ASIO_ENABLE_OLD_SSL)
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SSL_DETAIL_IMPL_ENGINE_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/5b1aba70/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/openssl_init.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/openssl_init.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/openssl_init.ipp
new file mode 100644
index 0000000..5104a41
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/ssl/detail/impl/openssl_init.ipp
@@ -0,0 +1,145 @@
+//
+// ssl/detail/impl/openssl_init.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
+#define ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <vector>
+#include "asio/detail/assert.hpp"
+#include "asio/detail/mutex.hpp"
+#include "asio/detail/tss_ptr.hpp"
+#include "asio/ssl/detail/openssl_init.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ssl {
+namespace detail {
+
+class openssl_init_base::do_init
+{
+public:
+  do_init()
+  {
+    ::SSL_library_init();
+    ::SSL_load_error_strings();        
+    ::OpenSSL_add_all_algorithms();
+
+    mutexes_.resize(::CRYPTO_num_locks());
+    for (size_t i = 0; i < mutexes_.size(); ++i)
+      mutexes_[i].reset(new asio::detail::mutex);
+    ::CRYPTO_set_locking_callback(&do_init::openssl_locking_func);
+    ::CRYPTO_set_id_callback(&do_init::openssl_id_func);
+
+#if !defined(SSL_OP_NO_COMPRESSION) \
+  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+    null_compression_methods_ = sk_SSL_COMP_new_null();
+#endif // !defined(SSL_OP_NO_COMPRESSION)
+       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+  }
+
+  ~do_init()
+  {
+#if !defined(SSL_OP_NO_COMPRESSION) \
+  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+    sk_SSL_COMP_free(null_compression_methods_);
+#endif // !defined(SSL_OP_NO_COMPRESSION)
+       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+
+    ::CRYPTO_set_id_callback(0);
+    ::CRYPTO_set_locking_callback(0);
+    ::ERR_free_strings();
+    ::ERR_remove_state(0);
+    ::EVP_cleanup();
+    ::CRYPTO_cleanup_all_ex_data();
+    ::CONF_modules_unload(1);
+#if !defined(OPENSSL_NO_ENGINE)
+    ::ENGINE_cleanup();
+#endif // !defined(OPENSSL_NO_ENGINE)
+  }
+
+#if !defined(SSL_OP_NO_COMPRESSION) \
+  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+  STACK_OF(SSL_COMP)* get_null_compression_methods() const
+  {
+    return null_compression_methods_;
+  }
+#endif // !defined(SSL_OP_NO_COMPRESSION)
+       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+
+private:
+  static unsigned long openssl_id_func()
+  {
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+    return ::GetCurrentThreadId();
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+    void* id = instance()->thread_id_;
+    if (id == 0)
+      instance()->thread_id_ = id = &id; // Ugh.
+    ASIO_ASSERT(sizeof(unsigned long) >= sizeof(void*));
+    return reinterpret_cast<unsigned long>(id);
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  }
+
+  static void openssl_locking_func(int mode, int n, 
+    const char* /*file*/, int /*line*/)
+  {
+    if (mode & CRYPTO_LOCK)
+      instance()->mutexes_[n]->lock();
+    else
+      instance()->mutexes_[n]->unlock();
+  }
+
+  // Mutexes to be used in locking callbacks.
+  std::vector<asio::detail::shared_ptr<
+        asio::detail::mutex> > mutexes_;
+
+#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
+  // The thread identifiers to be used by openssl.
+  asio::detail::tss_ptr<void> thread_id_;
+#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
+
+#if !defined(SSL_OP_NO_COMPRESSION) \
+  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+  STACK_OF(SSL_COMP)* null_compression_methods_;
+#endif // !defined(SSL_OP_NO_COMPRESSION)
+       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+};
+
+asio::detail::shared_ptr<openssl_init_base::do_init>
+openssl_init_base::instance()
+{
+  static asio::detail::shared_ptr<do_init> init(new do_init);
+  return init;
+}
+
+#if !defined(SSL_OP_NO_COMPRESSION) \
+  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+STACK_OF(SSL_COMP)* openssl_init_base::get_null_compression_methods()
+{
+  return instance()->get_null_compression_methods();
+}
+#endif // !defined(SSL_OP_NO_COMPRESSION)
+       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP


Mime
View raw message