Add two extra Boost dependencies, upgrade to 1.47.0ks/boost1.47

author: Kevin Smith <git@kismith.co.uk> 2012-08-02 20:41:55 (GMT)
committer: Kevin Smith <git@kismith.co.uk> 2012-08-02 21:03:09 (GMT)
commit: d5ace22054203c7989691ae8b3fa4e4784d1b57e (patch)
tree: 64d400cdb10644967df183d0f202fcbf8160a773 /3rdParty/Boost/src/boost/asio
parent: 6f26d9aa86f0909af13b23b1a925b8d492e74154 (diff)
download: swift-contrib-d5ace22054203c7989691ae8b3fa4e4784d1b57e.zip
swift-contrib-d5ace22054203c7989691ae8b3fa4e4784d1b57e.tar.bz2
192 files changed, 13973 insertions, 2009 deletions
diff --git a/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
index a79967f..bdbcec1 100644
--- a/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
@@ -19,6 +19,7 @@
 #include <cstddef>
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/datagram_socket_service.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
@@ -42,8 +43,12 @@ class basic_datagram_socket
   : public basic_socket<Protocol, DatagramSocketService>
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// socket.
+  typedef typename DatagramSocketService::native_handle_type native_type;
+
   /// The native representation of a socket.
-  typedef typename DatagramSocketService::native_type native_type;
+  typedef typename DatagramSocketService::native_handle_type native_handle_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -121,12 +126,48 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_datagram_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_socket)
+      const protocol_type& protocol, const native_handle_type& native_socket)
     : basic_socket<Protocol, DatagramSocketService>(
         io_service, protocol, native_socket)
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_datagram_socket from another.
+  /**
+   * This constructor moves a datagram socket from one object to another.
+   *
+   * @param other The other basic_datagram_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_datagram_socket(io_service&) constructor.
+   */
+  basic_datagram_socket(basic_datagram_socket&& other)
+    : basic_socket<Protocol, DatagramSocketService>(
+        BOOST_ASIO_MOVE_CAST(basic_datagram_socket)(other))
+  {
+  }
+
+  /// Move-assign a basic_datagram_socket from another.
+  /**
+   * This assignment operator moves a datagram socket from one object to
+   * another.
+   *
+   * @param other The other basic_datagram_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_datagram_socket(io_service&) constructor.
+   */
+  basic_datagram_socket& operator=(basic_datagram_socket&& other)
+  {
+    basic_socket<Protocol, DatagramSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_datagram_socket)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Send some data on a connected socket.
   /**
    * This function is used to send data on the datagram socket. The function
@@ -153,8 +194,9 @@ public:
   std::size_t send(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "send");
     return s;
   }
 
@@ -180,9 +222,9 @@ public:
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
+    boost::asio::detail::throw_error(ec, "send");
     return s;
   }
 
@@ -207,7 +249,8 @@ public:
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->service.send(this->implementation, buffers, flags, ec);
+    return this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
   }
 
   /// Start an asynchronous send on a connected socket.
@@ -247,9 +290,15 @@ public:
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers, WriteHandler handler)
+  void async_send(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send on a connected socket.
@@ -283,9 +332,15 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send(this->implementation, buffers, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Send a datagram to the specified endpoint.
@@ -318,9 +373,9 @@ public:
       const endpoint_type& destination)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send_to(
+        this->get_implementation(), buffers, destination, 0, ec);
+    boost::asio::detail::throw_error(ec, "send_to");
     return s;
   }
 
@@ -345,9 +400,9 @@ public:
       const endpoint_type& destination, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send_to(
+        this->get_implementation(), buffers, destination, flags, ec);
+    boost::asio::detail::throw_error(ec, "send_to");
     return s;
   }
 
@@ -372,7 +427,7 @@ public:
       const endpoint_type& destination, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->service.send_to(this->implementation,
+    return this->get_service().send_to(this->get_implementation(),
         buffers, destination, flags, ec);
   }
 
@@ -415,10 +470,15 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, WriteHandler handler)
+      const endpoint_type& destination,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send_to(this->implementation, buffers, destination, 0,
-        handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send_to(this->get_implementation(), buffers,
+        destination, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send.
@@ -451,10 +511,14 @@ public:
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
-      WriteHandler handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send_to(this->implementation, buffers, destination,
-        flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send_to(this->get_implementation(), buffers,
+        destination, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data on a connected socket.
@@ -485,9 +549,9 @@ public:
   std::size_t receive(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "receive");
     return s;
   }
 
@@ -514,9 +578,9 @@ public:
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, flags, ec);
+    boost::asio::detail::throw_error(ec, "receive");
     return s;
   }
 
@@ -542,7 +606,8 @@ public:
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->service.receive(this->implementation, buffers, flags, ec);
+    return this->get_service().receive(
+        this->get_implementation(), buffers, flags, ec);
   }
 
   /// Start an asynchronous receive on a connected socket.
@@ -582,9 +647,15 @@ public:
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers, ReadHandler handler)
+  void async_receive(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive on a connected socket.
@@ -617,9 +688,15 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive(this->implementation, buffers, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Receive a datagram with the endpoint of the sender.
@@ -653,9 +730,9 @@ public:
       endpoint_type& sender_endpoint)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive_from(
+        this->get_implementation(), buffers, sender_endpoint, 0, ec);
+    boost::asio::detail::throw_error(ec, "receive_from");
     return s;
   }
   
@@ -680,9 +757,9 @@ public:
       endpoint_type& sender_endpoint, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive_from(
+        this->get_implementation(), buffers, sender_endpoint, flags, ec);
+    boost::asio::detail::throw_error(ec, "receive_from");
     return s;
   }
   
@@ -707,8 +784,8 @@ public:
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->service.receive_from(this->implementation, buffers,
-        sender_endpoint, flags, ec);
+    return this->get_service().receive_from(this->get_implementation(),
+        buffers, sender_endpoint, flags, ec);
   }
 
   /// Start an asynchronous receive.
@@ -749,10 +826,15 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, ReadHandler handler)
+      endpoint_type& sender_endpoint,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive_from(this->get_implementation(), buffers,
+        sender_endpoint, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive.
@@ -787,10 +869,14 @@ public:
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      ReadHandler handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive_from(this->get_implementation(), buffers,
+        sender_endpoint, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp b/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
index 452999d..c90cbee 100644
--- a/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
@@ -19,6 +19,7 @@
 #include <cstddef>
 #include <boost/asio/basic_io_object.hpp>
 #include <boost/asio/deadline_timer_service.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
@@ -161,7 +162,7 @@ public:
   {
     boost::system::error_code ec;
     this->service.expires_at(this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "expires_at");
   }
 
   /// Constructor to set a particular expiry time relative to now.
@@ -180,7 +181,7 @@ public:
   {
     boost::system::error_code ec;
     this->service.expires_from_now(this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "expires_from_now");
   }
 
   /// Cancel any asynchronous operations that are waiting on the timer.
@@ -209,7 +210,7 @@ public:
   {
     boost::system::error_code ec;
     std::size_t s = this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "cancel");
     return s;
   }
 
@@ -240,6 +241,67 @@ public:
     return this->service.cancel(this->implementation, ec);
   }
 
+  /// Cancels one asynchronous operation that is waiting on the timer.
+  /**
+   * This function forces the completion of one pending asynchronous wait
+   * operation against the timer. Handlers are cancelled in FIFO order. The
+   * handler for the cancelled operation will be invoked with the
+   * boost::asio::error::operation_aborted error code.
+   *
+   * Cancelling the timer does not change the expiry time.
+   *
+   * @return The number of asynchronous operations that were cancelled. That is,
+   * either 0 or 1.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note If the timer has already expired when cancel_one() is called, then
+   * the handlers for asynchronous wait operations will:
+   *
+   * @li have already been invoked; or
+   *
+   * @li have been queued for invocation in the near future.
+   *
+   * These handlers can no longer be cancelled, and therefore are passed an
+   * error code that indicates the successful completion of the wait operation.
+   */
+  std::size_t cancel_one()
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->service.cancel_one(this->implementation, ec);
+    boost::asio::detail::throw_error(ec, "cancel_one");
+    return s;
+  }
+
+  /// Cancels one asynchronous operation that is waiting on the timer.
+  /**
+   * This function forces the completion of one pending asynchronous wait
+   * operation against the timer. Handlers are cancelled in FIFO order. The
+   * handler for the cancelled operation will be invoked with the
+   * boost::asio::error::operation_aborted error code.
+   *
+   * Cancelling the timer does not change the expiry time.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @return The number of asynchronous operations that were cancelled. That is,
+   * either 0 or 1.
+   *
+   * @note If the timer has already expired when cancel_one() is called, then
+   * the handlers for asynchronous wait operations will:
+   *
+   * @li have already been invoked; or
+   *
+   * @li have been queued for invocation in the near future.
+   *
+   * These handlers can no longer be cancelled, and therefore are passed an
+   * error code that indicates the successful completion of the wait operation.
+   */
+  std::size_t cancel_one(boost::system::error_code& ec)
+  {
+    return this->service.cancel_one(this->implementation, ec);
+  }
+
   /// Get the timer's expiry time as an absolute time.
   /**
    * This function may be used to obtain the timer's current expiry time.
@@ -277,7 +339,7 @@ public:
     boost::system::error_code ec;
     std::size_t s = this->service.expires_at(
         this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "expires_at");
     return s;
   }
 
@@ -346,7 +408,7 @@ public:
     boost::system::error_code ec;
     std::size_t s = this->service.expires_from_now(
         this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "expires_from_now");
     return s;
   }
 
@@ -390,7 +452,7 @@ public:
   {
     boost::system::error_code ec;
     this->service.wait(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "wait");
   }
 
   /// Perform a blocking wait on the timer.
@@ -430,9 +492,14 @@ public:
    * boost::asio::io_service::post().
    */
   template <typename WaitHandler>
-  void async_wait(WaitHandler handler)
+  void async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    this->service.async_wait(this->implementation, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WaitHandler.
+    BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
+
+    this->service.async_wait(this->implementation,
+        BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_io_object.hpp b/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
index 8e137e7..57a7397 100644
--- a/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
@@ -16,7 +16,6 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -24,10 +23,42 @@
 namespace boost {
 namespace asio {
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+namespace detail
+{
+  // Type trait used to determine whether a service supports move.
+  template <typename IoObjectService>
+  class service_has_move
+  {
+  private:
+    typedef IoObjectService service_type;
+    typedef typename service_type::implementation_type implementation_type;
+
+    template <typename T, typename U>
+    static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
+    static char (&eval(...))[2];
+
+  public:
+    static const bool value =
+      sizeof(service_has_move::eval(
+        static_cast<service_type*>(0),
+        static_cast<implementation_type*>(0))) == 1;
+  };
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
 /// Base class for all I/O objects.
+/**
+ * @note All I/O objects are non-copyable. However, when using C++0x, certain
+ * I/O objects do support move construction and move assignment.
+ */
+#if !defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 template <typename IoObjectService>
+#else
+template <typename IoObjectService,
+    bool Movable = detail::service_has_move<IoObjectService>::value>
+#endif
 class basic_io_object
-  : private noncopyable
 {
 public:
   /// The type of the service that will be used to provide I/O operations.
@@ -36,20 +67,6 @@ public:
   /// The underlying implementation type of I/O object.
   typedef typename service_type::implementation_type implementation_type;
 
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  /**
-   * This function may be used to obtain the io_service object that the I/O
-   * object uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A reference to the io_service object that the I/O object will use
-   * to dispatch handlers. Ownership is not transferred to the caller.
-   */
-  boost::asio::io_service& io_service()
-  {
-    return service.get_io_service();
-  }
-
   /// Get the io_service associated with the object.
   /**
    * This function may be used to obtain the io_service object that the I/O
@@ -67,7 +84,7 @@ protected:
   /// Construct a basic_io_object.
   /**
    * Performs:
-   * @code service.construct(implementation); @endcode
+   * @code get_service().construct(get_implementation()); @endcode
    */
   explicit basic_io_object(boost::asio::io_service& io_service)
     : service(boost::asio::use_service<IoObjectService>(io_service))
@@ -75,22 +92,147 @@ protected:
     service.construct(implementation);
   }
 
+#if defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_io_object.
+  /**
+   * Performs:
+   * @code get_service().move_construct(
+   *     get_implementation(), other.get_implementation()); @endcode
+   *
+   * @note Available only for services that support movability,
+   */
+  basic_io_object(basic_io_object&& other);
+
+  /// Move-assign a basic_io_object.
+  /**
+   * Performs:
+   * @code get_service().move_assign(get_implementation(),
+   *     other.get_service(), other.get_implementation()); @endcode
+   *
+   * @note Available only for services that support movability,
+   */
+  basic_io_object& operator=(basic_io_object&& other);
+#endif // defined(GENERATING_DOCUMENTATION)
+
   /// Protected destructor to prevent deletion through this type.
   /**
    * Performs:
-   * @code service.destroy(implementation); @endcode
+   * @code get_service().destroy(get_implementation()); @endcode
    */
   ~basic_io_object()
   {
     service.destroy(implementation);
   }
 
-  /// The service associated with the I/O object.
+  /// Get the service associated with the I/O object.
+  service_type& get_service()
+  {
+    return service;
+  }
+
+  /// Get the service associated with the I/O object.
+  const service_type& get_service() const
+  {
+    return service;
+  }
+
+  /// (Deprecated: Use get_service().) The service associated with the I/O
+  /// object.
+  /**
+   * @note Available only for services that do not support movability.
+   */
   service_type& service;
 
-  /// The underlying implementation of the I/O object.
+  /// Get the underlying implementation of the I/O object.
+  implementation_type& get_implementation()
+  {
+    return implementation;
+  }
+
+  /// Get the underlying implementation of the I/O object.
+  const implementation_type& get_implementation() const
+  {
+    return implementation;
+  }
+
+  /// (Deprecated: Use get_implementation().) The underlying implementation of
+  /// the I/O object.
   implementation_type implementation;
+
+private:
+  basic_io_object(const basic_io_object&);
+  basic_io_object& operator=(const basic_io_object&);
+};
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+// Specialisation for movable objects.
+template <typename IoObjectService>
+class basic_io_object<IoObjectService, true>
+{
+public:
+  typedef IoObjectService service_type;
+  typedef typename service_type::implementation_type implementation_type;
+
+  boost::asio::io_service& get_io_service()
+  {
+    return service_->get_io_service();
+  }
+
+protected:
+  explicit basic_io_object(boost::asio::io_service& io_service)
+    : service_(&boost::asio::use_service<IoObjectService>(io_service))
+  {
+    service_->construct(implementation);
+  }
+
+  basic_io_object(basic_io_object&& other)
+    : service_(&other.get_service())
+  {
+    service_->move_construct(implementation, other.implementation);
+  }
+
+  ~basic_io_object()
+  {
+    service_->destroy(implementation);
+  }
+
+  basic_io_object& operator=(basic_io_object&& other)
+  {
+    service_->move_assign(implementation,
+        *other.service_, other.implementation);
+    service_ = other.service_;
+    return *this;
+  }
+
+  service_type& get_service()
+  {
+    return *service_;
+  }
+
+  const service_type& get_service() const
+  {
+    return *service_;
+  }
+
+  implementation_type& get_implementation()
+  {
+    return implementation;
+  }
+
+  const implementation_type& get_implementation() const
+  {
+    return implementation;
+  }
+
+  implementation_type implementation;
+
+private:
+  basic_io_object(const basic_io_object&);
+  void operator=(const basic_io_object&);
+
+  IoObjectService* service_;
 };
+#endif // defined(BOOST_ASIO_HAS_MOVE)
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
index 0e58e7f..b29dd62 100644
--- a/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
@@ -18,6 +18,7 @@
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <boost/asio/basic_socket.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/raw_socket_service.hpp>
@@ -42,8 +43,12 @@ class basic_raw_socket
   : public basic_socket<Protocol, RawSocketService>
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// socket.
+  typedef typename RawSocketService::native_handle_type native_type;
+
   /// The native representation of a socket.
-  typedef typename RawSocketService::native_type native_type;
+  typedef typename RawSocketService::native_handle_type native_handle_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -121,12 +126,47 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_raw_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_socket)
+      const protocol_type& protocol, const native_handle_type& native_socket)
     : basic_socket<Protocol, RawSocketService>(
         io_service, protocol, native_socket)
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_raw_socket from another.
+  /**
+   * This constructor moves a raw socket from one object to another.
+   *
+   * @param other The other basic_raw_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_raw_socket(io_service&) constructor.
+   */
+  basic_raw_socket(basic_raw_socket&& other)
+    : basic_socket<Protocol, RawSocketService>(
+        BOOST_ASIO_MOVE_CAST(basic_raw_socket)(other))
+  {
+  }
+
+  /// Move-assign a basic_raw_socket from another.
+  /**
+   * This assignment operator moves a raw socket from one object to another.
+   *
+   * @param other The other basic_raw_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_raw_socket(io_service&) constructor.
+   */
+  basic_raw_socket& operator=(basic_raw_socket&& other)
+  {
+    basic_socket<Protocol, RawSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_raw_socket)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Send some data on a connected socket.
   /**
    * This function is used to send data on the raw socket. The function call
@@ -152,8 +192,9 @@ public:
   std::size_t send(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "send");
     return s;
   }
 
@@ -178,9 +219,9 @@ public:
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
+    boost::asio::detail::throw_error(ec, "send");
     return s;
   }
 
@@ -204,7 +245,8 @@ public:
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->service.send(this->implementation, buffers, flags, ec);
+    return this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
   }
 
   /// Start an asynchronous send on a connected socket.
@@ -243,9 +285,15 @@ public:
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers, WriteHandler handler)
+  void async_send(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send on a connected socket.
@@ -278,9 +326,15 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send(this->implementation, buffers, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Send raw data to the specified endpoint.
@@ -313,9 +367,9 @@ public:
       const endpoint_type& destination)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send_to(
+        this->get_implementation(), buffers, destination, 0, ec);
+    boost::asio::detail::throw_error(ec, "send_to");
     return s;
   }
 
@@ -340,9 +394,9 @@ public:
       const endpoint_type& destination, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send_to(
+        this->get_implementation(), buffers, destination, flags, ec);
+    boost::asio::detail::throw_error(ec, "send_to");
     return s;
   }
 
@@ -367,7 +421,7 @@ public:
       const endpoint_type& destination, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->service.send_to(this->implementation,
+    return this->get_service().send_to(this->get_implementation(),
         buffers, destination, flags, ec);
   }
 
@@ -410,10 +464,15 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, WriteHandler handler)
+      const endpoint_type& destination,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send_to(this->implementation, buffers, destination, 0,
-        handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send_to(this->get_implementation(), buffers,
+        destination, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send.
@@ -446,10 +505,14 @@ public:
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
-      WriteHandler handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send_to(this->implementation, buffers, destination,
-        flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send_to(this->get_implementation(), buffers,
+        destination, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data on a connected socket.
@@ -480,9 +543,9 @@ public:
   std::size_t receive(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "receive");
     return s;
   }
 
@@ -509,9 +572,9 @@ public:
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, flags, ec);
+    boost::asio::detail::throw_error(ec, "receive");
     return s;
   }
 
@@ -537,7 +600,8 @@ public:
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->service.receive(this->implementation, buffers, flags, ec);
+    return this->get_service().receive(
+        this->get_implementation(), buffers, flags, ec);
   }
 
   /// Start an asynchronous receive on a connected socket.
@@ -577,9 +641,15 @@ public:
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers, ReadHandler handler)
+  void async_receive(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive on a connected socket.
@@ -612,9 +682,15 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive(this->implementation, buffers, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Receive raw data with the endpoint of the sender.
@@ -648,9 +724,9 @@ public:
       endpoint_type& sender_endpoint)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive_from(
+        this->get_implementation(), buffers, sender_endpoint, 0, ec);
+    boost::asio::detail::throw_error(ec, "receive_from");
     return s;
   }
   
@@ -675,9 +751,9 @@ public:
       endpoint_type& sender_endpoint, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive_from(
+        this->get_implementation(), buffers, sender_endpoint, flags, ec);
+    boost::asio::detail::throw_error(ec, "receive_from");
     return s;
   }
   
@@ -702,8 +778,8 @@ public:
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->service.receive_from(this->implementation, buffers,
-        sender_endpoint, flags, ec);
+    return this->get_service().receive_from(this->get_implementation(),
+        buffers, sender_endpoint, flags, ec);
   }
 
   /// Start an asynchronous receive.
@@ -744,10 +820,15 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, ReadHandler handler)
+      endpoint_type& sender_endpoint,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive_from(this->get_implementation(), buffers,
+        sender_endpoint, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive.
@@ -782,10 +863,14 @@ public:
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      ReadHandler handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive_from(this->get_implementation(), buffers,
+        sender_endpoint, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp
new file mode 100644
index 0000000..17e15e7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp
@@ -0,0 +1,514 @@
+//
+// basic_seq_packet_socket.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_BASIC_SEQ_PACKET_SOCKET_HPP
+#define BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_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/basic_socket.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/seq_packet_socket_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides sequenced packet socket functionality.
+/**
+ * The basic_seq_packet_socket class template provides asynchronous and blocking
+ * sequenced packet socket functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Protocol,
+    typename SeqPacketSocketService = seq_packet_socket_service<Protocol> >
+class basic_seq_packet_socket
+  : public basic_socket<Protocol, SeqPacketSocketService>
+{
+public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// socket.
+  typedef typename SeqPacketSocketService::native_handle_type native_type;
+
+  /// The native representation of a socket.
+  typedef typename SeqPacketSocketService::native_handle_type
+    native_handle_type;
+
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// Construct a basic_seq_packet_socket without opening it.
+  /**
+   * This constructor creates a sequenced packet socket without opening it. The
+   * socket needs to be opened and then connected or accepted before data can
+   * be sent or received on it.
+   *
+   * @param io_service The io_service object that the sequenced packet socket
+   * will use to dispatch handlers for any asynchronous operations performed on
+   * the socket.
+   */
+  explicit basic_seq_packet_socket(boost::asio::io_service& io_service)
+    : basic_socket<Protocol, SeqPacketSocketService>(io_service)
+  {
+  }
+
+  /// Construct and open a basic_seq_packet_socket.
+  /**
+   * This constructor creates and opens a sequenced_packet socket. The socket
+   * needs to be connected or accepted before data can be sent or received on
+   * it.
+   *
+   * @param io_service The io_service object that the sequenced packet socket
+   * will use to dispatch handlers for any asynchronous operations performed on
+   * the socket.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_seq_packet_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol)
+    : basic_socket<Protocol, SeqPacketSocketService>(io_service, protocol)
+  {
+  }
+
+  /// Construct a basic_seq_packet_socket, opening it and binding it to the
+  /// given local endpoint.
+  /**
+   * This constructor creates a sequenced packet socket and automatically opens
+   * it bound to the specified endpoint on the local machine. The protocol used
+   * is the protocol associated with the given endpoint.
+   *
+   * @param io_service The io_service object that the sequenced packet socket
+   * will use to dispatch handlers for any asynchronous operations performed on
+   * the socket.
+   *
+   * @param endpoint An endpoint on the local machine to which the sequenced
+   * packet socket will be bound.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_seq_packet_socket(boost::asio::io_service& io_service,
+      const endpoint_type& endpoint)
+    : basic_socket<Protocol, SeqPacketSocketService>(io_service, endpoint)
+  {
+  }
+
+  /// Construct a basic_seq_packet_socket on an existing native socket.
+  /**
+   * This constructor creates a sequenced packet socket object to hold an
+   * existing native socket.
+   *
+   * @param io_service The io_service object that the sequenced packet socket
+   * will use to dispatch handlers for any asynchronous operations performed on
+   * the socket.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @param native_socket The new underlying socket implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_seq_packet_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol, const native_handle_type& native_socket)
+    : basic_socket<Protocol, SeqPacketSocketService>(
+        io_service, protocol, native_socket)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_seq_packet_socket from another.
+  /**
+   * This constructor moves a sequenced packet socket from one object to
+   * another.
+   *
+   * @param other The other basic_seq_packet_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_seq_packet_socket(io_service&) constructor.
+   */
+  basic_seq_packet_socket(basic_seq_packet_socket&& other)
+    : basic_socket<Protocol, SeqPacketSocketService>(
+        BOOST_ASIO_MOVE_CAST(basic_seq_packet_socket)(other))
+  {
+  }
+
+  /// Move-assign a basic_seq_packet_socket from another.
+  /**
+   * This assignment operator moves a sequenced packet socket from one object to
+   * another.
+   *
+   * @param other The other basic_seq_packet_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_seq_packet_socket(io_service&) constructor.
+   */
+  basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
+  {
+    basic_socket<Protocol, SeqPacketSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_seq_packet_socket)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Send some data on the socket.
+  /**
+   * This function is used to send data on the sequenced packet socket. The
+   * function call will block until the data has been sent successfully, or an
+   * until error occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @returns The number of bytes sent.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @par Example
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * socket.send(boost::asio::buffer(data, size), 0);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t send(const ConstBufferSequence& buffers,
+      socket_base::message_flags flags)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
+    boost::asio::detail::throw_error(ec, "send");
+    return s;
+  }
+
+  /// Send some data on the socket.
+  /**
+   * This function is used to send data on the sequenced packet socket. The
+   * function call will block the data has been sent successfully, or an until
+   * error occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes sent. Returns 0 if an error occurred.
+   *
+   * @note The send operation may not transmit all of the data to the peer.
+   * Consider using the @ref write function if you need to ensure that all data
+   * is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t send(const ConstBufferSequence& buffers,
+      socket_base::message_flags flags, boost::system::error_code& ec)
+  {
+    return this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
+  }
+
+  /// Start an asynchronous send.
+  /**
+   * This function is used to asynchronously send data on the sequenced packet
+   * socket. The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be sent on the socket. Although
+   * the buffers object may be copied as necessary, ownership of the underlying
+   * memory blocks is retained by the caller, which must guarantee that they
+   * remain valid until the handler is called.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param handler The handler to be called when the send 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.
+   *   std::size_t bytes_transferred           // Number of bytes sent.
+   * ); @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().
+   *
+   * @par Example
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * socket.async_send(boost::asio::buffer(data, size), 0, handler);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence, typename WriteHandler>
+  void async_send(const ConstBufferSequence& buffers,
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+  }
+
+  /// Receive some data on the socket.
+  /**
+   * This function is used to receive data on the sequenced packet socket. The
+   * function call will block until data has been received successfully, or
+   * until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param out_flags After the receive call completes, contains flags
+   * associated with the received data. For example, if the
+   * socket_base::message_end_of_record bit is set then the received data marks
+   * the end of a record.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @par Example
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.receive(boost::asio::buffer(data, size), out_flags);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t receive(const MutableBufferSequence& buffers,
+      socket_base::message_flags& out_flags)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, 0, out_flags, ec);
+    boost::asio::detail::throw_error(ec, "receive");
+    return s;
+  }
+
+  /// Receive some data on the socket.
+  /**
+   * This function is used to receive data on the sequenced packet socket. The
+   * function call will block until data has been received successfully, or
+   * until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param in_flags Flags specifying how the receive call is to be made.
+   *
+   * @param out_flags After the receive call completes, contains flags
+   * associated with the received data. For example, if the
+   * socket_base::message_end_of_record bit is set then the received data marks
+   * the end of a record.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The receive operation may not receive all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that the
+   * requested amount of data is read before the blocking operation completes.
+   *
+   * @par Example
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.receive(boost::asio::buffer(data, size), 0, out_flags);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t receive(const MutableBufferSequence& buffers,
+      socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, in_flags, out_flags, ec);
+    boost::asio::detail::throw_error(ec, "receive");
+    return s;
+  }
+
+  /// Receive some data on a connected socket.
+  /**
+   * This function is used to receive data on the sequenced packet socket. The
+   * function call will block until data has been received successfully, or
+   * until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param in_flags Flags specifying how the receive call is to be made.
+   *
+   * @param out_flags After the receive call completes, contains flags
+   * associated with the received data. For example, if the
+   * socket_base::message_end_of_record bit is set then the received data marks
+   * the end of a record.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes received. Returns 0 if an error occurred.
+   *
+   * @note The receive operation may not receive all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that the
+   * requested amount of data is read before the blocking operation completes.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t receive(const MutableBufferSequence& buffers,
+      socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    return this->get_service().receive(this->get_implementation(),
+        buffers, in_flags, out_flags, ec);
+  }
+
+  /// Start an asynchronous receive.
+  /**
+   * This function is used to asynchronously receive data from the sequenced
+   * packet socket. The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param out_flags Once the asynchronous operation completes, contains flags
+   * associated with the received data. For example, if the
+   * socket_base::message_end_of_record bit is set then the received data marks
+   * the end of a record. The caller must guarantee that the referenced
+   * variable remains valid until the handler is called.
+   *
+   * @param handler The handler to be called when the receive 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.
+   *   std::size_t bytes_transferred           // Number of bytes received.
+   * ); @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().
+   *
+   * @par Example
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.async_receive(boost::asio::buffer(data, size), out_flags, handler);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence, typename ReadHandler>
+  void async_receive(const MutableBufferSequence& buffers,
+      socket_base::message_flags& out_flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(), buffers,
+        0, out_flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+  }
+
+  /// Start an asynchronous receive.
+  /**
+   * This function is used to asynchronously receive data from the sequenced
+   * data socket. The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param in_flags Flags specifying how the receive call is to be made.
+   *
+   * @param out_flags Once the asynchronous operation completes, contains flags
+   * associated with the received data. For example, if the
+   * socket_base::message_end_of_record bit is set then the received data marks
+   * the end of a record. The caller must guarantee that the referenced
+   * variable remains valid until the handler is called.
+   *
+   * @param handler The handler to be called when the receive 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.
+   *   std::size_t bytes_transferred           // Number of bytes received.
+   * ); @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().
+   *
+   * @par Example
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.async_receive(
+   *     boost::asio::buffer(data, size),
+   *     0, out_flags, handler);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence, typename ReadHandler>
+  void async_receive(const MutableBufferSequence& buffers,
+      socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(), buffers,
+        in_flags, out_flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp b/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
index 744fd3b..a94b0e5 100644
--- a/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
@@ -23,6 +23,7 @@
 
 #include <string>
 #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/serial_port_base.hpp>
@@ -48,8 +49,12 @@ class basic_serial_port
     public serial_port_base
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// serial port.
+  typedef typename SerialPortService::native_handle_type native_type;
+
   /// The native representation of a serial port.
-  typedef typename SerialPortService::native_type native_type;
+  typedef typename SerialPortService::native_handle_type native_handle_type;
 
   /// A basic_serial_port is always the lowest layer.
   typedef basic_serial_port<SerialPortService> lowest_layer_type;
@@ -82,8 +87,8 @@ public:
     : basic_io_object<SerialPortService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, device, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().open(this->get_implementation(), device, ec);
+    boost::asio::detail::throw_error(ec, "open");
   }
 
   /// Construct and open a basic_serial_port.
@@ -102,8 +107,8 @@ public:
     : basic_io_object<SerialPortService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, device, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().open(this->get_implementation(), device, ec);
+    boost::asio::detail::throw_error(ec, "open");
   }
 
   /// Construct a basic_serial_port on an existing native serial port.
@@ -119,13 +124,49 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_serial_port(boost::asio::io_service& io_service,
-      const native_type& native_serial_port)
+      const native_handle_type& native_serial_port)
     : basic_io_object<SerialPortService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, native_serial_port, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        native_serial_port, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_serial_port from another.
+  /**
+   * This constructor moves a serial port from one object to another.
+   *
+   * @param other The other basic_serial_port object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_serial_port(io_service&) constructor.
+   */
+  basic_serial_port(basic_serial_port&& other)
+    : basic_io_object<SerialPortService>(
+        BOOST_ASIO_MOVE_CAST(basic_serial_port)(other))
+  {
+  }
+
+  /// Move-assign a basic_serial_port from another.
+  /**
+   * This assignment operator moves a serial port from one object to another.
+   *
+   * @param other The other basic_serial_port object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_serial_port(io_service&) constructor.
+   */
+  basic_serial_port& operator=(basic_serial_port&& other)
+  {
+    basic_io_object<SerialPortService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_serial_port)(other));
+    return *this;
   }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Get a reference to the lowest layer.
   /**
@@ -166,8 +207,8 @@ public:
   void open(const std::string& device)
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, device, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().open(this->get_implementation(), device, ec);
+    boost::asio::detail::throw_error(ec, "open");
   }
 
   /// Open the serial port using the specified device name.
@@ -182,7 +223,7 @@ public:
   boost::system::error_code open(const std::string& device,
       boost::system::error_code& ec)
   {
-    return this->service.open(this->implementation, device, ec);
+    return this->get_service().open(this->get_implementation(), device, ec);
   }
 
   /// Assign an existing native serial port to the serial port.
@@ -193,11 +234,12 @@ public:
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const native_type& native_serial_port)
+  void assign(const native_handle_type& native_serial_port)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, native_serial_port, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        native_serial_port, ec);
+    boost::asio::detail::throw_error(ec, "assign");
   }
 
   /// Assign an existing native serial port to the serial port.
@@ -208,16 +250,17 @@ public:
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  boost::system::error_code assign(const native_type& native_serial_port,
+  boost::system::error_code assign(const native_handle_type& native_serial_port,
       boost::system::error_code& ec)
   {
-    return this->service.assign(this->implementation, native_serial_port, ec);
+    return this->get_service().assign(this->get_implementation(),
+        native_serial_port, ec);
   }
 
   /// Determine whether the serial port is open.
   bool is_open() const
   {
-    return this->service.is_open(this->implementation);
+    return this->get_service().is_open(this->get_implementation());
   }
 
   /// Close the serial port.
@@ -231,8 +274,8 @@ public:
   void close()
   {
     boost::system::error_code ec;
-    this->service.close(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().close(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
   }
 
   /// Close the serial port.
@@ -245,10 +288,11 @@ public:
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->service.close(this->implementation, ec);
+    return this->get_service().close(this->get_implementation(), ec);
   }
 
-  /// Get the native serial port representation.
+  /// (Deprecated: Use native_handle().) Get the native serial port
+  /// representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * serial port. This is intended to allow access to native serial port
@@ -256,7 +300,18 @@ public:
    */
   native_type native()
   {
-    return this->service.native(this->implementation);
+    return this->get_service().native_handle(this->get_implementation());
+  }
+
+  /// Get the native serial port representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * serial port. This is intended to allow access to native serial port
+   * functionality that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return this->get_service().native_handle(this->get_implementation());
   }
 
   /// Cancel all asynchronous operations associated with the serial port.
@@ -270,8 +325,8 @@ public:
   void cancel()
   {
     boost::system::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
   }
 
   /// Cancel all asynchronous operations associated with the serial port.
@@ -284,7 +339,7 @@ public:
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    return this->get_service().cancel(this->get_implementation(), ec);
   }
 
   /// Send a break sequence to the serial port.
@@ -297,8 +352,8 @@ public:
   void send_break()
   {
     boost::system::error_code ec;
-    this->service.send_break(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().send_break(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "send_break");
   }
 
   /// Send a break sequence to the serial port.
@@ -310,7 +365,7 @@ public:
    */
   boost::system::error_code send_break(boost::system::error_code& ec)
   {
-    return this->service.send_break(this->implementation, ec);
+    return this->get_service().send_break(this->get_implementation(), ec);
   }
 
   /// Set an option on the serial port.
@@ -332,8 +387,8 @@ public:
   void set_option(const SettableSerialPortOption& option)
   {
     boost::system::error_code ec;
-    this->service.set_option(this->implementation, option, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    boost::asio::detail::throw_error(ec, "set_option");
   }
 
   /// Set an option on the serial port.
@@ -355,7 +410,8 @@ public:
   boost::system::error_code set_option(const SettableSerialPortOption& option,
       boost::system::error_code& ec)
   {
-    return this->service.set_option(this->implementation, option, ec);
+    return this->get_service().set_option(
+        this->get_implementation(), option, ec);
   }
 
   /// Get an option from the serial port.
@@ -378,8 +434,8 @@ public:
   void get_option(GettableSerialPortOption& option)
   {
     boost::system::error_code ec;
-    this->service.get_option(this->implementation, option, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    boost::asio::detail::throw_error(ec, "get_option");
   }
 
   /// Get an option from the serial port.
@@ -402,7 +458,8 @@ public:
   boost::system::error_code get_option(GettableSerialPortOption& option,
       boost::system::error_code& ec)
   {
-    return this->service.get_option(this->implementation, option, ec);
+    return this->get_service().get_option(
+        this->get_implementation(), option, ec);
   }
 
   /// Write some data to the serial port.
@@ -436,8 +493,9 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.write_some(this->implementation, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
     return s;
   }
 
@@ -461,7 +519,8 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.write_some(this->implementation, buffers, ec);
+    return this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
   }
 
   /// Start an asynchronous write.
@@ -501,9 +560,14 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_write_some(this->implementation, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_write_some(this->get_implementation(),
+        buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the serial port.
@@ -538,8 +602,9 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.read_some(this->implementation, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
     return s;
   }
 
@@ -564,7 +629,8 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.read_some(this->implementation, buffers, ec);
+    return this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
   }
 
   /// Start an asynchronous read.
@@ -605,9 +671,14 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_read_some(this->implementation, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_read_some(this->get_implementation(),
+        buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp b/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp
new file mode 100644
index 0000000..2f84a14
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp
@@ -0,0 +1,384 @@
+//
+// basic_signal_set.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_BASIC_SIGNAL_SET_HPP
+#define BOOST_ASIO_BASIC_SIGNAL_SET_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/signal_set_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides signal functionality.
+/**
+ * The basic_signal_set class template provides the ability to perform an
+ * asynchronous wait for one or more signals to occur.
+ *
+ * Most applications will use the boost::asio::signal_set typedef.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Example
+ * Performing an asynchronous wait:
+ * @code
+ * void handler(
+ *     const boost::system::error_code& error,
+ *     int signal_number)
+ * {
+ *   if (!error)
+ *   {
+ *     // A signal occurred.
+ *   }
+ * }
+ *
+ * ...
+ *
+ * // Construct a signal set registered for process termination.
+ * boost::asio::signal_set signals(io_service, SIGINT, SIGTERM);
+ *
+ * // Start an asynchronous wait for one of the signals to occur.
+ * signals.async_wait(handler);
+ * @endcode
+ *
+ * @par Queueing of signal notifications
+ *
+ * If a signal is registered with a signal_set, and the signal occurs when
+ * there are no waiting handlers, then the signal notification is queued. The
+ * next async_wait operation on that signal_set will dequeue the notification.
+ * If multiple notifications are queued, subsequent async_wait operations
+ * dequeue them one at a time. Signal notifications are dequeued in order of
+ * ascending signal number.
+ *
+ * If a signal number is removed from a signal_set (using the @c remove or @c
+ * erase member functions) then any queued notifications for that signal are
+ * discarded.
+ *
+ * @par Multiple registration of signals
+ *
+ * The same signal number may be registered with different signal_set objects.
+ * When the signal occurs, one handler is called for each signal_set object.
+ *
+ * Note that multiple registration only works for signals that are registered
+ * using Asio. The application must not also register a signal handler using
+ * functions such as @c signal() or @c sigaction().
+ *
+ * @par Signal masking on POSIX platforms
+ *
+ * POSIX allows signals to be blocked using functions such as @c sigprocmask()
+ * and @c pthread_sigmask(). For signals to be delivered, programs must ensure
+ * that any signals registered using signal_set objects are unblocked in at
+ * least one thread.
+ */
+template <typename SignalSetService = signal_set_service>
+class basic_signal_set
+  : public basic_io_object<SignalSetService>
+{
+public:
+  /// Construct a signal set without adding any signals.
+  /**
+   * This constructor creates a signal set without registering for any signals.
+   *
+   * @param io_service The io_service object that the signal set will use to
+   * dispatch handlers for any asynchronous operations performed on the set.
+   */
+  explicit basic_signal_set(boost::asio::io_service& io_service)
+    : basic_io_object<SignalSetService>(io_service)
+  {
+  }
+
+  /// Construct a signal set and add one signal.
+  /**
+   * This constructor creates a signal set and registers for one signal.
+   *
+   * @param io_service The io_service object that the signal set will use to
+   * dispatch handlers for any asynchronous operations performed on the set.
+   *
+   * @param signal_number_1 The signal number to be added.
+   *
+   * @note This constructor is equivalent to performing:
+   * @code boost::asio::signal_set signals(io_service);
+   * signals.add(signal_number_1); @endcode
+   */
+  basic_signal_set(boost::asio::io_service& io_service, int signal_number_1)
+    : basic_io_object<SignalSetService>(io_service)
+  {
+    boost::system::error_code ec;
+    this->service.add(this->implementation, signal_number_1, ec);
+    boost::asio::detail::throw_error(ec, "add");
+  }
+
+  /// Construct a signal set and add two signals.
+  /**
+   * This constructor creates a signal set and registers for two signals.
+   *
+   * @param io_service The io_service object that the signal set will use to
+   * dispatch handlers for any asynchronous operations performed on the set.
+   *
+   * @param signal_number_1 The first signal number to be added.
+   *
+   * @param signal_number_2 The second signal number to be added.
+   *
+   * @note This constructor is equivalent to performing:
+   * @code boost::asio::signal_set signals(io_service);
+   * signals.add(signal_number_1);
+   * signals.add(signal_number_2); @endcode
+   */
+  basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
+      int signal_number_2)
+    : basic_io_object<SignalSetService>(io_service)
+  {
+    boost::system::error_code ec;
+    this->service.add(this->implementation, signal_number_1, ec);
+    boost::asio::detail::throw_error(ec, "add");
+    this->service.add(this->implementation, signal_number_2, ec);
+    boost::asio::detail::throw_error(ec, "add");
+  }
+
+  /// Construct a signal set and add three signals.
+  /**
+   * This constructor creates a signal set and registers for three signals.
+   *
+   * @param io_service The io_service object that the signal set will use to
+   * dispatch handlers for any asynchronous operations performed on the set.
+   *
+   * @param signal_number_1 The first signal number to be added.
+   *
+   * @param signal_number_2 The second signal number to be added.
+   *
+   * @param signal_number_3 The third signal number to be added.
+   *
+   * @note This constructor is equivalent to performing:
+   * @code boost::asio::signal_set signals(io_service);
+   * signals.add(signal_number_1);
+   * signals.add(signal_number_2);
+   * signals.add(signal_number_3); @endcode
+   */
+  basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
+      int signal_number_2, int signal_number_3)
+    : basic_io_object<SignalSetService>(io_service)
+  {
+    boost::system::error_code ec;
+    this->service.add(this->implementation, signal_number_1, ec);
+    boost::asio::detail::throw_error(ec, "add");
+    this->service.add(this->implementation, signal_number_2, ec);
+    boost::asio::detail::throw_error(ec, "add");
+    this->service.add(this->implementation, signal_number_3, ec);
+    boost::asio::detail::throw_error(ec, "add");
+  }
+
+  /// Add a signal to a signal_set.
+  /**
+   * This function adds the specified signal to the set. It has no effect if the
+   * signal is already in the set.
+   *
+   * @param signal_number The signal to be added to the set.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void add(int signal_number)
+  {
+    boost::system::error_code ec;
+    this->service.add(this->implementation, signal_number, ec);
+    boost::asio::detail::throw_error(ec, "add");
+  }
+
+  /// Add a signal to a signal_set.
+  /**
+   * This function adds the specified signal to the set. It has no effect if the
+   * signal is already in the set.
+   *
+   * @param signal_number The signal to be added to the set.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code add(int signal_number,
+      boost::system::error_code& ec)
+  {
+    return this->service.add(this->implementation, signal_number, ec);
+  }
+
+  /// Remove a signal from a signal_set.
+  /**
+   * This function removes the specified signal from the set. It has no effect
+   * if the signal is not in the set.
+   *
+   * @param signal_number The signal to be removed from the set.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note Removes any notifications that have been queued for the specified
+   * signal number.
+   */
+  void remove(int signal_number)
+  {
+    boost::system::error_code ec;
+    this->service.remove(this->implementation, signal_number, ec);
+    boost::asio::detail::throw_error(ec, "remove");
+  }
+
+  /// Remove a signal from a signal_set.
+  /**
+   * This function removes the specified signal from the set. It has no effect
+   * if the signal is not in the set.
+   *
+   * @param signal_number The signal to be removed from the set.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Removes any notifications that have been queued for the specified
+   * signal number.
+   */
+  boost::system::error_code remove(int signal_number,
+      boost::system::error_code& ec)
+  {
+    return this->service.remove(this->implementation, signal_number, ec);
+  }
+
+  /// Remove all signals from a signal_set.
+  /**
+   * This function removes all signals from the set. It has no effect if the set
+   * is already empty.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note Removes all queued notifications.
+   */
+  void clear()
+  {
+    boost::system::error_code ec;
+    this->service.clear(this->implementation, ec);
+    boost::asio::detail::throw_error(ec, "clear");
+  }
+
+  /// Remove all signals from a signal_set.
+  /**
+   * This function removes all signals from the set. It has no effect if the set
+   * is already empty.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Removes all queued notifications.
+   */
+  boost::system::error_code clear(boost::system::error_code& ec)
+  {
+    return this->service.clear(this->implementation, ec);
+  }
+
+  /// Cancel all operations associated with the signal set.
+  /**
+   * This function forces the completion of any pending asynchronous wait
+   * operations against the signal set. The handler for each cancelled
+   * operation will be invoked with the boost::asio::error::operation_aborted
+   * error code.
+   *
+   * Cancellation does not alter the set of registered signals.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note If a registered signal occurred before cancel() is called, then the
+   * handlers for asynchronous wait operations will:
+   *
+   * @li have already been invoked; or
+   *
+   * @li have been queued for invocation in the near future.
+   *
+   * These handlers can no longer be cancelled, and therefore are passed an
+   * error code that indicates the successful completion of the wait operation.
+   */
+  void cancel()
+  {
+    boost::system::error_code ec;
+    this->service.cancel(this->implementation, ec);
+    boost::asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all operations associated with the signal set.
+  /**
+   * This function forces the completion of any pending asynchronous wait
+   * operations against the signal set. The handler for each cancelled
+   * operation will be invoked with the boost::asio::error::operation_aborted
+   * error code.
+   *
+   * Cancellation does not alter the set of registered signals.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note If a registered signal occurred before cancel() is called, then the
+   * handlers for asynchronous wait operations will:
+   *
+   * @li have already been invoked; or
+   *
+   * @li have been queued for invocation in the near future.
+   *
+   * These handlers can no longer be cancelled, and therefore are passed an
+   * error code that indicates the successful completion of the wait operation.
+   */
+  boost::system::error_code cancel(boost::system::error_code& ec)
+  {
+    return this->service.cancel(this->implementation, ec);
+  }
+
+  /// Start an asynchronous operation to wait for a signal to be delivered.
+  /**
+   * This function may be used to initiate an asynchronous wait against the
+   * signal set. It always returns immediately.
+   *
+   * For each call to async_wait(), the supplied handler will be called exactly
+   * once. The handler will be called when:
+   *
+   * @li One of the registered signals in the signal set occurs; or
+   *
+   * @li The signal set was cancelled, in which case the handler is passed the
+   * error code boost::asio::error::operation_aborted.
+   *
+   * @param handler The handler to be called when the signal occurs. 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.
+   *   int signal_number // Indicates which signal occurred.
+   * ); @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().
+   */
+  template <typename SignalHandler>
+  void async_wait(BOOST_ASIO_MOVE_ARG(SignalHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a SignalHandler.
+    BOOST_ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
+
+    this->service.async_wait(this->implementation,
+        BOOST_ASIO_MOVE_CAST(SignalHandler)(handler));
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_SIGNAL_SET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_socket.hpp
index 11ce5c9..28c5be1 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket.hpp
@@ -17,6 +17,7 @@
 
 #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/socket_base.hpp>
@@ -41,8 +42,12 @@ class basic_socket
     public socket_base
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// socket.
+  typedef typename SocketService::native_handle_type native_type;
+
   /// The native representation of a socket.
-  typedef typename SocketService::native_type native_type;
+  typedef typename SocketService::native_handle_type native_handle_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -81,8 +86,8 @@ public:
     : basic_io_object<SocketService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, protocol, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    boost::asio::detail::throw_error(ec, "open");
   }
 
   /// Construct a basic_socket, opening it and binding it to the given local
@@ -105,10 +110,11 @@ public:
     : basic_io_object<SocketService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, endpoint.protocol(), ec);
-    boost::asio::detail::throw_error(ec);
-    this->service.bind(this->implementation, endpoint, ec);
-    boost::asio::detail::throw_error(ec);
+    const protocol_type protocol = endpoint.protocol();
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    boost::asio::detail::throw_error(ec, "open");
+    this->get_service().bind(this->get_implementation(), endpoint, ec);
+    boost::asio::detail::throw_error(ec, "bind");
   }
 
   /// Construct a basic_socket on an existing native socket.
@@ -125,14 +131,50 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_socket)
+      const protocol_type& protocol, const native_handle_type& native_socket)
     : basic_io_object<SocketService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, protocol, native_socket, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        protocol, native_socket, ec);
+    boost::asio::detail::throw_error(ec, "assign");
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_socket from another.
+  /**
+   * This constructor moves a socket from one object to another.
+   *
+   * @param other The other basic_socket object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket(io_service&) constructor.
+   */
+  basic_socket(basic_socket&& other)
+    : basic_io_object<SocketService>(
+        BOOST_ASIO_MOVE_CAST(basic_socket)(other))
+  {
+  }
+
+  /// Move-assign a basic_socket from another.
+  /**
+   * This assignment operator moves a socket from one object to another.
+   *
+   * @param other The other basic_socket object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket(io_service&) constructor.
+   */
+  basic_socket& operator=(basic_socket&& other)
+  {
+    basic_io_object<SocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_socket)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Get a reference to the lowest layer.
   /**
    * This function returns a reference to the lowest layer in a stack of
@@ -178,8 +220,8 @@ public:
   void open(const protocol_type& protocol = protocol_type())
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, protocol, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    boost::asio::detail::throw_error(ec, "open");
   }
 
   /// Open the socket using the specified protocol.
@@ -204,7 +246,7 @@ public:
   boost::system::error_code open(const protocol_type& protocol,
       boost::system::error_code& ec)
   {
-    return this->service.open(this->implementation, protocol, ec);
+    return this->get_service().open(this->get_implementation(), protocol, ec);
   }
 
   /// Assign an existing native socket to the socket.
@@ -217,11 +259,13 @@ public:
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const protocol_type& protocol, const native_type& native_socket)
+  void assign(const protocol_type& protocol,
+      const native_handle_type& native_socket)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, protocol, native_socket, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        protocol, native_socket, ec);
+    boost::asio::detail::throw_error(ec, "assign");
   }
 
   /// Assign an existing native socket to the socket.
@@ -235,16 +279,16 @@ public:
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code assign(const protocol_type& protocol,
-      const native_type& native_socket, boost::system::error_code& ec)
+      const native_handle_type& native_socket, boost::system::error_code& ec)
   {
-    return this->service.assign(this->implementation,
+    return this->get_service().assign(this->get_implementation(),
         protocol, native_socket, ec);
   }
 
   /// Determine whether the socket is open.
   bool is_open() const
   {
-    return this->service.is_open(this->implementation);
+    return this->get_service().is_open(this->get_implementation());
   }
 
   /// Close the socket.
@@ -253,7 +297,8 @@ public:
    * or connect operations will be cancelled immediately, and will complete
    * with the boost::asio::error::operation_aborted error.
    *
-   * @throws boost::system::system_error Thrown on failure.
+   * @throws boost::system::system_error Thrown on failure. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
    *
    * @note For portable behaviour with respect to graceful closure of a
    * connected socket, call shutdown() before closing the socket.
@@ -261,8 +306,8 @@ public:
   void close()
   {
     boost::system::error_code ec;
-    this->service.close(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().close(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
   }
 
   /// Close the socket.
@@ -271,7 +316,8 @@ public:
    * or connect operations will be cancelled immediately, and will complete
    * with the boost::asio::error::operation_aborted error.
    *
-   * @param ec Set to indicate what error occurred, if any.
+   * @param ec Set to indicate what error occurred, if any. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
    *
    * @par Example
    * @code
@@ -290,10 +336,10 @@ public:
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->service.close(this->implementation, ec);
+    return this->get_service().close(this->get_implementation(), ec);
   }
 
-  /// Get the native socket representation.
+  /// (Deprecated: Use native_handle().) Get the native socket representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * socket. This is intended to allow access to native socket functionality
@@ -301,7 +347,18 @@ public:
    */
   native_type native()
   {
-    return this->service.native(this->implementation);
+    return this->get_service().native_handle(this->get_implementation());
+  }
+
+  /// Get the native socket representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * socket. This is intended to allow access to native socket functionality
+   * that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return this->get_service().native_handle(this->get_implementation());
   }
 
   /// Cancel all asynchronous operations associated with the socket.
@@ -348,8 +405,8 @@ public:
   void cancel()
   {
     boost::system::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
   }
 
   /// Cancel all asynchronous operations associated with the socket.
@@ -395,7 +452,7 @@ public:
 #endif
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    return this->get_service().cancel(this->get_implementation(), ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
@@ -411,8 +468,8 @@ public:
   bool at_mark() const
   {
     boost::system::error_code ec;
-    bool b = this->service.at_mark(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    bool b = this->get_service().at_mark(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "at_mark");
     return b;
   }
 
@@ -428,7 +485,7 @@ public:
    */
   bool at_mark(boost::system::error_code& ec) const
   {
-    return this->service.at_mark(this->implementation, ec);
+    return this->get_service().at_mark(this->get_implementation(), ec);
   }
 
   /// Determine the number of bytes available for reading.
@@ -444,8 +501,9 @@ public:
   std::size_t available() const
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.available(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().available(
+        this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "available");
     return s;
   }
 
@@ -461,7 +519,7 @@ public:
    */
   std::size_t available(boost::system::error_code& ec) const
   {
-    return this->service.available(this->implementation, ec);
+    return this->get_service().available(this->get_implementation(), ec);
   }
 
   /// Bind the socket to the given local endpoint.
@@ -485,8 +543,8 @@ public:
   void bind(const endpoint_type& endpoint)
   {
     boost::system::error_code ec;
-    this->service.bind(this->implementation, endpoint, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().bind(this->get_implementation(), endpoint, ec);
+    boost::asio::detail::throw_error(ec, "bind");
   }
 
   /// Bind the socket to the given local endpoint.
@@ -515,7 +573,7 @@ public:
   boost::system::error_code bind(const endpoint_type& endpoint,
       boost::system::error_code& ec)
   {
-    return this->service.bind(this->implementation, endpoint, ec);
+    return this->get_service().bind(this->get_implementation(), endpoint, ec);
   }
 
   /// Connect the socket to the specified endpoint.
@@ -546,11 +604,12 @@ public:
     boost::system::error_code ec;
     if (!is_open())
     {
-      this->service.open(this->implementation, peer_endpoint.protocol(), ec);
-      boost::asio::detail::throw_error(ec);
+      this->get_service().open(this->get_implementation(),
+          peer_endpoint.protocol(), ec);
+      boost::asio::detail::throw_error(ec, "connect");
     }
-    this->service.connect(this->implementation, peer_endpoint, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
+    boost::asio::detail::throw_error(ec, "connect");
   }
 
   /// Connect the socket to the specified endpoint.
@@ -586,14 +645,15 @@ public:
   {
     if (!is_open())
     {
-      if (this->service.open(this->implementation,
+      if (this->get_service().open(this->get_implementation(),
             peer_endpoint.protocol(), ec))
       {
         return ec;
       }
     }
 
-    return this->service.connect(this->implementation, peer_endpoint, ec);
+    return this->get_service().connect(
+        this->get_implementation(), peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
@@ -638,21 +698,28 @@ public:
    * @endcode
    */
   template <typename ConnectHandler>
-  void async_connect(const endpoint_type& peer_endpoint, ConnectHandler handler)
+  void async_connect(const endpoint_type& peer_endpoint,
+      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ConnectHandler.
+    BOOST_ASIO_CONNECT_HANDLER_CHECK(ConnectHandler, handler) type_check;
+
     if (!is_open())
     {
       boost::system::error_code ec;
-      if (this->service.open(this->implementation,
-            peer_endpoint.protocol(), ec))
+      const protocol_type protocol = peer_endpoint.protocol();
+      if (this->get_service().open(this->get_implementation(), protocol, ec))
       {
         this->get_io_service().post(
-            boost::asio::detail::bind_handler(handler, ec));
+            boost::asio::detail::bind_handler(
+              BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler), ec));
         return;
       }
     }
 
-    this->service.async_connect(this->implementation, peer_endpoint, handler);
+    this->get_service().async_connect(this->get_implementation(),
+        peer_endpoint, BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
   }
 
   /// Set an option on the socket.
@@ -693,8 +760,8 @@ public:
   void set_option(const SettableSocketOption& option)
   {
     boost::system::error_code ec;
-    this->service.set_option(this->implementation, option, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    boost::asio::detail::throw_error(ec, "set_option");
   }
 
   /// Set an option on the socket.
@@ -740,7 +807,8 @@ public:
   boost::system::error_code set_option(const SettableSocketOption& option,
       boost::system::error_code& ec)
   {
-    return this->service.set_option(this->implementation, option, ec);
+    return this->get_service().set_option(
+        this->get_implementation(), option, ec);
   }
 
   /// Get an option from the socket.
@@ -782,8 +850,8 @@ public:
   void get_option(GettableSocketOption& option) const
   {
     boost::system::error_code ec;
-    this->service.get_option(this->implementation, option, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    boost::asio::detail::throw_error(ec, "get_option");
   }
 
   /// Get an option from the socket.
@@ -830,7 +898,8 @@ public:
   boost::system::error_code get_option(GettableSocketOption& option,
       boost::system::error_code& ec) const
   {
-    return this->service.get_option(this->implementation, option, ec);
+    return this->get_service().get_option(
+        this->get_implementation(), option, ec);
   }
 
   /// Perform an IO control command on the socket.
@@ -859,8 +928,8 @@ public:
   void io_control(IoControlCommand& command)
   {
     boost::system::error_code ec;
-    this->service.io_control(this->implementation, command, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    boost::asio::detail::throw_error(ec, "io_control");
   }
 
   /// Perform an IO control command on the socket.
@@ -894,7 +963,338 @@ public:
   boost::system::error_code io_control(IoControlCommand& command,
       boost::system::error_code& ec)
   {
-    return this->service.io_control(this->implementation, command, ec);
+    return this->get_service().io_control(
+        this->get_implementation(), command, ec);
+  }
+
+  /// Gets the non-blocking mode of the socket.
+  /**
+   * @returns @c true if the socket's synchronous operations will fail with
+   * boost::asio::error::would_block if they are unable to perform the requested
+   * operation immediately. If @c false, synchronous operations will block
+   * until complete.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  bool non_blocking() const
+  {
+    return this->get_service().non_blocking(this->get_implementation());
+  }
+
+  /// Sets the non-blocking mode of the socket.
+  /**
+   * @param mode If @c true, the socket's synchronous operations will fail with
+   * boost::asio::error::would_block if they are unable to perform the requested
+   * operation immediately. If @c false, synchronous operations will block
+   * until complete.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  void non_blocking(bool mode)
+  {
+    boost::system::error_code ec;
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    boost::asio::detail::throw_error(ec, "non_blocking");
+  }
+
+  /// Sets the non-blocking mode of the socket.
+  /**
+   * @param mode If @c true, the socket's synchronous operations will fail with
+   * boost::asio::error::would_block if they are unable to perform the requested
+   * operation immediately. If @c false, synchronous operations will block
+   * until complete.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  boost::system::error_code non_blocking(
+      bool mode, boost::system::error_code& ec)
+  {
+    return this->get_service().non_blocking(
+        this->get_implementation(), mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native socket implementation.
+  /**
+   * This function is used to retrieve the non-blocking mode of the underlying
+   * native socket. This mode has no effect on the behaviour of the socket
+   * object's synchronous operations.
+   *
+   * @returns @c true if the underlying socket is in non-blocking mode and
+   * direct system calls may fail with boost::asio::error::would_block (or the
+   * equivalent system error).
+   *
+   * @note The current non-blocking mode is cached by the socket object.
+   * Consequently, the return value may be incorrect if the non-blocking mode
+   * was set directly on the native socket.
+   *
+   * @par Example
+   * This function is intended to allow the encapsulation of arbitrary
+   * non-blocking system calls as asynchronous operations, in a way that is
+   * transparent to the user of the socket object. The following example
+   * illustrates how Linux's @c sendfile system call might be encapsulated:
+   * @code template <typename Handler>
+   * struct sendfile_op
+   * {
+   *   tcp::socket& sock_;
+   *   int fd_;
+   *   Handler handler_;
+   *   off_t offset_;
+   *   std::size_t total_bytes_transferred_;
+   *
+   *   // Function call operator meeting WriteHandler requirements.
+   *   // Used as the handler for the async_write_some operation.
+   *   void operator()(boost::system::error_code ec, std::size_t)
+   *   {
+   *     // Put the underlying socket into non-blocking mode.
+   *     if (!ec)
+   *       if (!sock_.native_non_blocking())
+   *         sock_.native_non_blocking(true, ec);
+   *
+   *     if (!ec)
+   *     {
+   *       for (;;)
+   *       {
+   *         // Try the system call.
+   *         errno = 0;
+   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
+   *         ec = boost::system::error_code(n < 0 ? errno : 0,
+   *             boost::asio::error::get_system_category());
+   *         total_bytes_transferred_ += ec ? 0 : n;
+   *
+   *         // Retry operation immediately if interrupted by signal.
+   *         if (ec == boost::asio::error::interrupted)
+   *           continue;
+   *
+   *         // Check if we need to run the operation again.
+   *         if (ec == boost::asio::error::would_block
+   *             || ec == boost::asio::error::try_again)
+   *         {
+   *           // We have to wait for the socket to become ready again.
+   *           sock_.async_write_some(boost::asio::null_buffers(), *this);
+   *           return;
+   *         }
+   *
+   *         if (ec || n == 0)
+   *         {
+   *           // An error occurred, or we have reached the end of the file.
+   *           // Either way we must exit the loop so we can call the handler.
+   *           break;
+   *         }
+   *
+   *         // Loop around to try calling sendfile again.
+   *       }
+   *     }
+   *
+   *     // Pass result back to user's handler.
+   *     handler_(ec, total_bytes_transferred_);
+   *   }
+   * };
+   *
+   * template <typename Handler>
+   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
+   * {
+   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
+   *   sock.async_write_some(boost::asio::null_buffers(), op);
+   * } @endcode
+   */
+  bool native_non_blocking() const
+  {
+    return this->get_service().native_non_blocking(this->get_implementation());
+  }
+
+  /// Sets the non-blocking mode of the native socket implementation.
+  /**
+   * This function is used to modify the non-blocking mode of the underlying
+   * native socket. It has no effect on the behaviour of the socket object's
+   * synchronous operations.
+   *
+   * @param mode If @c true, the underlying socket is put into non-blocking
+   * mode and direct system calls may fail with boost::asio::error::would_block
+   * (or the equivalent system error).
+   *
+   * @throws boost::system::system_error Thrown on failure. If the @c mode is
+   * @c false, but the current value of @c non_blocking() is @c true, this
+   * function fails with boost::asio::error::invalid_argument, as the
+   * combination does not make sense.
+   *
+   * @par Example
+   * This function is intended to allow the encapsulation of arbitrary
+   * non-blocking system calls as asynchronous operations, in a way that is
+   * transparent to the user of the socket object. The following example
+   * illustrates how Linux's @c sendfile system call might be encapsulated:
+   * @code template <typename Handler>
+   * struct sendfile_op
+   * {
+   *   tcp::socket& sock_;
+   *   int fd_;
+   *   Handler handler_;
+   *   off_t offset_;
+   *   std::size_t total_bytes_transferred_;
+   *
+   *   // Function call operator meeting WriteHandler requirements.
+   *   // Used as the handler for the async_write_some operation.
+   *   void operator()(boost::system::error_code ec, std::size_t)
+   *   {
+   *     // Put the underlying socket into non-blocking mode.
+   *     if (!ec)
+   *       if (!sock_.native_non_blocking())
+   *         sock_.native_non_blocking(true, ec);
+   *
+   *     if (!ec)
+   *     {
+   *       for (;;)
+   *       {
+   *         // Try the system call.
+   *         errno = 0;
+   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
+   *         ec = boost::system::error_code(n < 0 ? errno : 0,
+   *             boost::asio::error::get_system_category());
+   *         total_bytes_transferred_ += ec ? 0 : n;
+   *
+   *         // Retry operation immediately if interrupted by signal.
+   *         if (ec == boost::asio::error::interrupted)
+   *           continue;
+   *
+   *         // Check if we need to run the operation again.
+   *         if (ec == boost::asio::error::would_block
+   *             || ec == boost::asio::error::try_again)
+   *         {
+   *           // We have to wait for the socket to become ready again.
+   *           sock_.async_write_some(boost::asio::null_buffers(), *this);
+   *           return;
+   *         }
+   *
+   *         if (ec || n == 0)
+   *         {
+   *           // An error occurred, or we have reached the end of the file.
+   *           // Either way we must exit the loop so we can call the handler.
+   *           break;
+   *         }
+   *
+   *         // Loop around to try calling sendfile again.
+   *       }
+   *     }
+   *
+   *     // Pass result back to user's handler.
+   *     handler_(ec, total_bytes_transferred_);
+   *   }
+   * };
+   *
+   * template <typename Handler>
+   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
+   * {
+   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
+   *   sock.async_write_some(boost::asio::null_buffers(), op);
+   * } @endcode
+   */
+  void native_non_blocking(bool mode)
+  {
+    boost::system::error_code ec;
+    this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
+    boost::asio::detail::throw_error(ec, "native_non_blocking");
+  }
+
+  /// Sets the non-blocking mode of the native socket implementation.
+  /**
+   * This function is used to modify the non-blocking mode of the underlying
+   * native socket. It has no effect on the behaviour of the socket object's
+   * synchronous operations.
+   *
+   * @param mode If @c true, the underlying socket is put into non-blocking
+   * mode and direct system calls may fail with boost::asio::error::would_block
+   * (or the equivalent system error).
+   *
+   * @param ec Set to indicate what error occurred, if any. If the @c mode is
+   * @c false, but the current value of @c non_blocking() is @c true, this
+   * function fails with boost::asio::error::invalid_argument, as the
+   * combination does not make sense.
+   *
+   * @par Example
+   * This function is intended to allow the encapsulation of arbitrary
+   * non-blocking system calls as asynchronous operations, in a way that is
+   * transparent to the user of the socket object. The following example
+   * illustrates how Linux's @c sendfile system call might be encapsulated:
+   * @code template <typename Handler>
+   * struct sendfile_op
+   * {
+   *   tcp::socket& sock_;
+   *   int fd_;
+   *   Handler handler_;
+   *   off_t offset_;
+   *   std::size_t total_bytes_transferred_;
+   *
+   *   // Function call operator meeting WriteHandler requirements.
+   *   // Used as the handler for the async_write_some operation.
+   *   void operator()(boost::system::error_code ec, std::size_t)
+   *   {
+   *     // Put the underlying socket into non-blocking mode.
+   *     if (!ec)
+   *       if (!sock_.native_non_blocking())
+   *         sock_.native_non_blocking(true, ec);
+   *
+   *     if (!ec)
+   *     {
+   *       for (;;)
+   *       {
+   *         // Try the system call.
+   *         errno = 0;
+   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
+   *         ec = boost::system::error_code(n < 0 ? errno : 0,
+   *             boost::asio::error::get_system_category());
+   *         total_bytes_transferred_ += ec ? 0 : n;
+   *
+   *         // Retry operation immediately if interrupted by signal.
+   *         if (ec == boost::asio::error::interrupted)
+   *           continue;
+   *
+   *         // Check if we need to run the operation again.
+   *         if (ec == boost::asio::error::would_block
+   *             || ec == boost::asio::error::try_again)
+   *         {
+   *           // We have to wait for the socket to become ready again.
+   *           sock_.async_write_some(boost::asio::null_buffers(), *this);
+   *           return;
+   *         }
+   *
+   *         if (ec || n == 0)
+   *         {
+   *           // An error occurred, or we have reached the end of the file.
+   *           // Either way we must exit the loop so we can call the handler.
+   *           break;
+   *         }
+   *
+   *         // Loop around to try calling sendfile again.
+   *       }
+   *     }
+   *
+   *     // Pass result back to user's handler.
+   *     handler_(ec, total_bytes_transferred_);
+   *   }
+   * };
+   *
+   * template <typename Handler>
+   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
+   * {
+   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
+   *   sock.async_write_some(boost::asio::null_buffers(), op);
+   * } @endcode
+   */
+  boost::system::error_code native_non_blocking(
+      bool mode, boost::system::error_code& ec)
+  {
+    return this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
   }
 
   /// Get the local endpoint of the socket.
@@ -915,8 +1315,9 @@ public:
   endpoint_type local_endpoint() const
   {
     boost::system::error_code ec;
-    endpoint_type ep = this->service.local_endpoint(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    endpoint_type ep = this->get_service().local_endpoint(
+        this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "local_endpoint");
     return ep;
   }
 
@@ -943,7 +1344,7 @@ public:
    */
   endpoint_type local_endpoint(boost::system::error_code& ec) const
   {
-    return this->service.local_endpoint(this->implementation, ec);
+    return this->get_service().local_endpoint(this->get_implementation(), ec);
   }
 
   /// Get the remote endpoint of the socket.
@@ -964,8 +1365,9 @@ public:
   endpoint_type remote_endpoint() const
   {
     boost::system::error_code ec;
-    endpoint_type ep = this->service.remote_endpoint(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    endpoint_type ep = this->get_service().remote_endpoint(
+        this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "remote_endpoint");
     return ep;
   }
 
@@ -992,7 +1394,7 @@ public:
    */
   endpoint_type remote_endpoint(boost::system::error_code& ec) const
   {
-    return this->service.remote_endpoint(this->implementation, ec);
+    return this->get_service().remote_endpoint(this->get_implementation(), ec);
   }
 
   /// Disable sends or receives on the socket.
@@ -1015,8 +1417,8 @@ public:
   void shutdown(shutdown_type what)
   {
     boost::system::error_code ec;
-    this->service.shutdown(this->implementation, what, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().shutdown(this->get_implementation(), what, ec);
+    boost::asio::detail::throw_error(ec, "shutdown");
   }
 
   /// Disable sends or receives on the socket.
@@ -1044,7 +1446,7 @@ public:
   boost::system::error_code shutdown(shutdown_type what,
       boost::system::error_code& ec)
   {
-    return this->service.shutdown(this->implementation, what, ec);
+    return this->get_service().shutdown(this->get_implementation(), what, ec);
   }
 
 protected:
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
index a877bc3..3203f59 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
@@ -18,6 +18,7 @@
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/basic_io_object.hpp>
 #include <boost/asio/basic_socket.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/socket_acceptor_service.hpp>
@@ -55,8 +56,12 @@ class basic_socket_acceptor
     public socket_base
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of an
+  /// acceptor.
+  typedef typename SocketAcceptorService::native_handle_type native_type;
+
   /// The native representation of an acceptor.
-  typedef typename SocketAcceptorService::native_type native_type;
+  typedef typename SocketAcceptorService::native_handle_type native_handle_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -96,8 +101,8 @@ public:
     : basic_io_object<SocketAcceptorService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, protocol, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    boost::asio::detail::throw_error(ec, "open");
   }
 
   /// Construct an acceptor opened on the given endpoint.
@@ -132,19 +137,20 @@ public:
     : basic_io_object<SocketAcceptorService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, endpoint.protocol(), ec);
-    boost::asio::detail::throw_error(ec);
+    const protocol_type protocol = endpoint.protocol();
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    boost::asio::detail::throw_error(ec, "open");
     if (reuse_addr)
     {
-      this->service.set_option(this->implementation,
+      this->get_service().set_option(this->get_implementation(),
           socket_base::reuse_address(true), ec);
-      boost::asio::detail::throw_error(ec);
+      boost::asio::detail::throw_error(ec, "set_option");
     }
-    this->service.bind(this->implementation, endpoint, ec);
-    boost::asio::detail::throw_error(ec);
-    this->service.listen(this->implementation,
+    this->get_service().bind(this->get_implementation(), endpoint, ec);
+    boost::asio::detail::throw_error(ec, "bind");
+    this->get_service().listen(this->get_implementation(),
         socket_base::max_connections, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "listen");
   }
 
   /// Construct a basic_socket_acceptor on an existing native acceptor.
@@ -163,14 +169,50 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket_acceptor(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_acceptor)
+      const protocol_type& protocol, const native_handle_type& native_acceptor)
     : basic_io_object<SocketAcceptorService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, protocol, native_acceptor, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        protocol, native_acceptor, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_socket_acceptor from another.
+  /**
+   * This constructor moves an acceptor from one object to another.
+   *
+   * @param other The other basic_socket_acceptor object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket_acceptor(io_service&) constructor.
+   */
+  basic_socket_acceptor(basic_socket_acceptor&& other)
+    : basic_io_object<SocketAcceptorService>(
+        BOOST_ASIO_MOVE_CAST(basic_socket_acceptor)(other))
+  {
   }
 
+  /// Move-assign a basic_socket_acceptor from another.
+  /**
+   * This assignment operator moves an acceptor from one object to another.
+   *
+   * @param other The other basic_socket_acceptor object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket_acceptor(io_service&) constructor.
+   */
+  basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
+  {
+    basic_io_object<SocketAcceptorService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_socket_acceptor)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Open the acceptor using the specified protocol.
   /**
    * This function opens the socket acceptor so that it will use the specified
@@ -189,8 +231,8 @@ public:
   void open(const protocol_type& protocol = protocol_type())
   {
     boost::system::error_code ec;
-    this->service.open(this->implementation, protocol, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    boost::asio::detail::throw_error(ec, "open");
   }
 
   /// Open the acceptor using the specified protocol.
@@ -216,7 +258,7 @@ public:
   boost::system::error_code open(const protocol_type& protocol,
       boost::system::error_code& ec)
   {
-    return this->service.open(this->implementation, protocol, ec);
+    return this->get_service().open(this->get_implementation(), protocol, ec);
   }
 
   /// Assigns an existing native acceptor to the acceptor.
@@ -229,11 +271,13 @@ public:
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const protocol_type& protocol, const native_type& native_acceptor)
+  void assign(const protocol_type& protocol,
+      const native_handle_type& native_acceptor)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, protocol, native_acceptor, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        protocol, native_acceptor, ec);
+    boost::asio::detail::throw_error(ec, "assign");
   }
 
   /// Assigns an existing native acceptor to the acceptor.
@@ -247,16 +291,16 @@ public:
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code assign(const protocol_type& protocol,
-      const native_type& native_acceptor, boost::system::error_code& ec)
+      const native_handle_type& native_acceptor, boost::system::error_code& ec)
   {
-    return this->service.assign(this->implementation,
+    return this->get_service().assign(this->get_implementation(),
         protocol, native_acceptor, ec);
   }
 
   /// Determine whether the acceptor is open.
   bool is_open() const
   {
-    return this->service.is_open(this->implementation);
+    return this->get_service().is_open(this->get_implementation());
   }
 
   /// Bind the acceptor to the given local endpoint.
@@ -279,8 +323,8 @@ public:
   void bind(const endpoint_type& endpoint)
   {
     boost::system::error_code ec;
-    this->service.bind(this->implementation, endpoint, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().bind(this->get_implementation(), endpoint, ec);
+    boost::asio::detail::throw_error(ec, "bind");
   }
 
   /// Bind the acceptor to the given local endpoint.
@@ -308,7 +352,7 @@ public:
   boost::system::error_code bind(const endpoint_type& endpoint,
       boost::system::error_code& ec)
   {
-    return this->service.bind(this->implementation, endpoint, ec);
+    return this->get_service().bind(this->get_implementation(), endpoint, ec);
   }
 
   /// Place the acceptor into the state where it will listen for new
@@ -324,8 +368,8 @@ public:
   void listen(int backlog = socket_base::max_connections)
   {
     boost::system::error_code ec;
-    this->service.listen(this->implementation, backlog, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().listen(this->get_implementation(), backlog, ec);
+    boost::asio::detail::throw_error(ec, "listen");
   }
 
   /// Place the acceptor into the state where it will listen for new
@@ -352,7 +396,7 @@ public:
    */
   boost::system::error_code listen(int backlog, boost::system::error_code& ec)
   {
-    return this->service.listen(this->implementation, backlog, ec);
+    return this->get_service().listen(this->get_implementation(), backlog, ec);
   }
 
   /// Close the acceptor.
@@ -368,8 +412,8 @@ public:
   void close()
   {
     boost::system::error_code ec;
-    this->service.close(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().close(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
   }
 
   /// Close the acceptor.
@@ -396,10 +440,10 @@ public:
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->service.close(this->implementation, ec);
+    return this->get_service().close(this->get_implementation(), ec);
   }
 
-  /// Get the native acceptor representation.
+  /// (Deprecated: Use native_handle().) Get the native acceptor representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * acceptor. This is intended to allow access to native acceptor functionality
@@ -407,7 +451,18 @@ public:
    */
   native_type native()
   {
-    return this->service.native(this->implementation);
+    return this->get_service().native_handle(this->get_implementation());
+  }
+
+  /// Get the native acceptor representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * acceptor. This is intended to allow access to native acceptor functionality
+   * that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return this->get_service().native_handle(this->get_implementation());
   }
 
   /// Cancel all asynchronous operations associated with the acceptor.
@@ -421,8 +476,8 @@ public:
   void cancel()
   {
     boost::system::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
   }
 
   /// Cancel all asynchronous operations associated with the acceptor.
@@ -435,7 +490,7 @@ public:
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    return this->get_service().cancel(this->get_implementation(), ec);
   }
 
   /// Set an option on the acceptor.
@@ -463,8 +518,8 @@ public:
   void set_option(const SettableSocketOption& option)
   {
     boost::system::error_code ec;
-    this->service.set_option(this->implementation, option, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    boost::asio::detail::throw_error(ec, "set_option");
   }
 
   /// Set an option on the acceptor.
@@ -497,7 +552,8 @@ public:
   boost::system::error_code set_option(const SettableSocketOption& option,
       boost::system::error_code& ec)
   {
-    return this->service.set_option(this->implementation, option, ec);
+    return this->get_service().set_option(
+        this->get_implementation(), option, ec);
   }
 
   /// Get an option from the acceptor.
@@ -526,8 +582,8 @@ public:
   void get_option(GettableSocketOption& option)
   {
     boost::system::error_code ec;
-    this->service.get_option(this->implementation, option, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    boost::asio::detail::throw_error(ec, "get_option");
   }
 
   /// Get an option from the acceptor.
@@ -561,7 +617,189 @@ public:
   boost::system::error_code get_option(GettableSocketOption& option,
       boost::system::error_code& ec)
   {
-    return this->service.get_option(this->implementation, option, ec);
+    return this->get_service().get_option(
+        this->get_implementation(), option, ec);
+  }
+
+  /// Perform an IO control command on the acceptor.
+  /**
+   * This function is used to execute an IO control command on the acceptor.
+   *
+   * @param command The IO control command to be performed on the acceptor.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @sa IoControlCommand @n
+   * boost::asio::socket_base::non_blocking_io
+   *
+   * @par Example
+   * Getting the number of bytes ready to read:
+   * @code
+   * boost::asio::ip::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::ip::tcp::acceptor::non_blocking_io command(true);
+   * socket.io_control(command);
+   * @endcode
+   */
+  template <typename IoControlCommand>
+  void io_control(IoControlCommand& command)
+  {
+    boost::system::error_code ec;
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    boost::asio::detail::throw_error(ec, "io_control");
+  }
+
+  /// Perform an IO control command on the acceptor.
+  /**
+   * This function is used to execute an IO control command on the acceptor.
+   *
+   * @param command The IO control command to be performed on the acceptor.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @sa IoControlCommand @n
+   * boost::asio::socket_base::non_blocking_io
+   *
+   * @par Example
+   * Getting the number of bytes ready to read:
+   * @code
+   * boost::asio::ip::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::ip::tcp::acceptor::non_blocking_io command(true);
+   * boost::system::error_code ec;
+   * socket.io_control(command, ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename IoControlCommand>
+  boost::system::error_code io_control(IoControlCommand& command,
+      boost::system::error_code& ec)
+  {
+    return this->get_service().io_control(
+        this->get_implementation(), command, ec);
+  }
+
+  /// Gets the non-blocking mode of the acceptor.
+  /**
+   * @returns @c true if the acceptor's synchronous operations will fail with
+   * boost::asio::error::would_block if they are unable to perform the requested
+   * operation immediately. If @c false, synchronous operations will block
+   * until complete.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  bool non_blocking() const
+  {
+    return this->get_service().non_blocking(this->get_implementation());
+  }
+
+  /// Sets the non-blocking mode of the acceptor.
+  /**
+   * @param mode If @c true, the acceptor's synchronous operations will fail
+   * with boost::asio::error::would_block if they are unable to perform the
+   * requested operation immediately. If @c false, synchronous operations will
+   * block until complete.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  void non_blocking(bool mode)
+  {
+    boost::system::error_code ec;
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    boost::asio::detail::throw_error(ec, "non_blocking");
+  }
+
+  /// Sets the non-blocking mode of the acceptor.
+  /**
+   * @param mode If @c true, the acceptor's synchronous operations will fail
+   * with boost::asio::error::would_block if they are unable to perform the
+   * requested operation immediately. If @c false, synchronous operations will
+   * block until complete.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  boost::system::error_code non_blocking(
+      bool mode, boost::system::error_code& ec)
+  {
+    return this->get_service().non_blocking(
+        this->get_implementation(), mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native acceptor implementation.
+  /**
+   * This function is used to retrieve the non-blocking mode of the underlying
+   * native acceptor. This mode has no effect on the behaviour of the acceptor
+   * object's synchronous operations.
+   *
+   * @returns @c true if the underlying acceptor is in non-blocking mode and
+   * direct system calls may fail with boost::asio::error::would_block (or the
+   * equivalent system error).
+   *
+   * @note The current non-blocking mode is cached by the acceptor object.
+   * Consequently, the return value may be incorrect if the non-blocking mode
+   * was set directly on the native acceptor.
+   */
+  bool native_non_blocking() const
+  {
+    return this->get_service().native_non_blocking(this->get_implementation());
+  }
+
+  /// Sets the non-blocking mode of the native acceptor implementation.
+  /**
+   * This function is used to modify the non-blocking mode of the underlying
+   * native acceptor. It has no effect on the behaviour of the acceptor object's
+   * synchronous operations.
+   *
+   * @param mode If @c true, the underlying acceptor is put into non-blocking
+   * mode and direct system calls may fail with boost::asio::error::would_block
+   * (or the equivalent system error).
+   *
+   * @throws boost::system::system_error Thrown on failure. If the @c mode is
+   * @c false, but the current value of @c non_blocking() is @c true, this
+   * function fails with boost::asio::error::invalid_argument, as the
+   * combination does not make sense.
+   */
+  void native_non_blocking(bool mode)
+  {
+    boost::system::error_code ec;
+    this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
+    boost::asio::detail::throw_error(ec, "native_non_blocking");
+  }
+
+  /// Sets the non-blocking mode of the native acceptor implementation.
+  /**
+   * This function is used to modify the non-blocking mode of the underlying
+   * native acceptor. It has no effect on the behaviour of the acceptor object's
+   * synchronous operations.
+   *
+   * @param mode If @c true, the underlying acceptor is put into non-blocking
+   * mode and direct system calls may fail with boost::asio::error::would_block
+   * (or the equivalent system error).
+   *
+   * @param ec Set to indicate what error occurred, if any. If the @c mode is
+   * @c false, but the current value of @c non_blocking() is @c true, this
+   * function fails with boost::asio::error::invalid_argument, as the
+   * combination does not make sense.
+   */
+  boost::system::error_code native_non_blocking(
+      bool mode, boost::system::error_code& ec)
+  {
+    return this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
   }
 
   /// Get the local endpoint of the acceptor.
@@ -582,8 +820,9 @@ public:
   endpoint_type local_endpoint() const
   {
     boost::system::error_code ec;
-    endpoint_type ep = this->service.local_endpoint(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    endpoint_type ep = this->get_service().local_endpoint(
+        this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "local_endpoint");
     return ep;
   }
 
@@ -611,7 +850,7 @@ public:
    */
   endpoint_type local_endpoint(boost::system::error_code& ec) const
   {
-    return this->service.local_endpoint(this->implementation, ec);
+    return this->get_service().local_endpoint(this->get_implementation(), ec);
   }
 
   /// Accept a new connection.
@@ -636,8 +875,8 @@ public:
   void accept(basic_socket<protocol_type, SocketService>& peer)
   {
     boost::system::error_code ec;
-    this->service.accept(this->implementation, peer, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().accept(this->get_implementation(), peer, 0, ec);
+    boost::asio::detail::throw_error(ec, "accept");
   }
 
   /// Accept a new connection.
@@ -668,7 +907,7 @@ public:
       basic_socket<protocol_type, SocketService>& peer,
       boost::system::error_code& ec)
   {
-    return this->service.accept(this->implementation, peer, 0, ec);
+    return this->get_service().accept(this->get_implementation(), peer, 0, ec);
   }
 
   /// Start an asynchronous accept.
@@ -711,9 +950,14 @@ public:
    */
   template <typename SocketService, typename AcceptHandler>
   void async_accept(basic_socket<protocol_type, SocketService>& peer,
-      AcceptHandler handler)
+      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
   {
-    this->service.async_accept(this->implementation, peer, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a AcceptHandler.
+    BOOST_ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
+
+    this->get_service().async_accept(this->get_implementation(),
+        peer, 0, BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
   }
 
   /// Accept a new connection and obtain the endpoint of the peer
@@ -744,8 +988,9 @@ public:
       endpoint_type& peer_endpoint)
   {
     boost::system::error_code ec;
-    this->service.accept(this->implementation, peer, &peer_endpoint, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().accept(this->get_implementation(),
+        peer, &peer_endpoint, ec);
+    boost::asio::detail::throw_error(ec, "accept");
   }
 
   /// Accept a new connection and obtain the endpoint of the peer
@@ -781,7 +1026,8 @@ public:
       basic_socket<protocol_type, SocketService>& peer,
       endpoint_type& peer_endpoint, boost::system::error_code& ec)
   {
-    return this->service.accept(this->implementation, peer, &peer_endpoint, ec);
+    return this->get_service().accept(
+        this->get_implementation(), peer, &peer_endpoint, ec);
   }
 
   /// Start an asynchronous accept.
@@ -812,10 +1058,14 @@ public:
    */
   template <typename SocketService, typename AcceptHandler>
   void async_accept(basic_socket<protocol_type, SocketService>& peer,
-      endpoint_type& peer_endpoint, AcceptHandler handler)
+      endpoint_type& peer_endpoint, BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
   {
-    this->service.async_accept(this->implementation,
-        peer, &peer_endpoint, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a AcceptHandler.
+    BOOST_ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
+
+    this->get_service().async_accept(this->get_implementation(), peer,
+        &peer_endpoint, BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
index 142f404..4dcf20e 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
@@ -19,34 +19,39 @@
 
 #if !defined(BOOST_NO_IOSTREAM)
 
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/utility/base_from_member.hpp>
 #include <boost/asio/basic_socket_streambuf.hpp>
 #include <boost/asio/stream_socket_service.hpp>
 
-#if !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
-#define BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY 5
-#endif // !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
+#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+# include <boost/preprocessor/arithmetic/inc.hpp>
+# include <boost/preprocessor/repetition/enum_binary_params.hpp>
+# include <boost/preprocessor/repetition/enum_params.hpp>
+# include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+# if !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
+#  define BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY 5
+# endif // !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
 //   explicit basic_socket_iostream(T1 x1, ..., Tn xn)
 //     : basic_iostream<char>(&this->boost::base_from_member<
-//         basic_socket_streambuf<Protocol, StreamSocketService> >::member)
+//         basic_socket_streambuf<Protocol, StreamSocketService,
+//           Time, TimeTraits, TimerService> >::member)
 //   {
 //     if (rdbuf()->connect(x1, ..., xn) == 0)
 //       this->setstate(std::ios_base::failbit);
 //   }
 // This macro should only persist within this file.
 
-#define BOOST_ASIO_PRIVATE_CTR_DEF(z, n, data) \
+# define BOOST_ASIO_PRIVATE_CTR_DEF(z, n, data) \
   template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
   explicit basic_socket_iostream(BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
     : std::basic_iostream<char>(&this->boost::base_from_member< \
-        basic_socket_streambuf<Protocol, StreamSocketService> >::member) \
+        basic_socket_streambuf<Protocol, StreamSocketService, \
+          Time, TimeTraits, TimerService> >::member) \
   { \
     tie(this); \
     if (rdbuf()->connect(BOOST_PP_ENUM_PARAMS(n, x)) == 0) \
@@ -63,7 +68,7 @@
 //   }
 // This macro should only persist within this file.
 
-#define BOOST_ASIO_PRIVATE_CONNECT_DEF(z, n, data) \
+# define BOOST_ASIO_PRIVATE_CONNECT_DEF(z, n, data) \
   template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
   void connect(BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
   { \
@@ -72,6 +77,8 @@
   } \
   /**/
 
+#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -79,17 +86,31 @@ namespace asio {
 
 /// Iostream interface for a socket.
 template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol> >
+    typename StreamSocketService = stream_socket_service<Protocol>,
+    typename Time = boost::posix_time::ptime,
+    typename TimeTraits = boost::asio::time_traits<Time>,
+    typename TimerService = deadline_timer_service<Time, TimeTraits> >
 class basic_socket_iostream
   : public boost::base_from_member<
-      basic_socket_streambuf<Protocol, StreamSocketService> >,
+      basic_socket_streambuf<Protocol, StreamSocketService,
+        Time, TimeTraits, TimerService> >,
     public std::basic_iostream<char>
 {
 public:
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// The time type.
+  typedef typename TimeTraits::time_type time_type;
+
+  /// The duration type.
+  typedef typename TimeTraits::duration_type duration_type;
+
   /// Construct a basic_socket_iostream without establishing a connection.
   basic_socket_iostream()
     : std::basic_iostream<char>(&this->boost::base_from_member<
-        basic_socket_streambuf<Protocol, StreamSocketService> >::member)
+        basic_socket_streambuf<Protocol, StreamSocketService,
+          Time, TimeTraits, TimerService> >::member)
   {
     tie(this);
   }
@@ -103,6 +124,17 @@ public:
    */
   template <typename T1, ..., typename TN>
   explicit basic_socket_iostream(T1 t1, ..., TN tn);
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  template <typename... T>
+  explicit basic_socket_iostream(T... x)
+    : std::basic_iostream<char>(&this->boost::base_from_member<
+        basic_socket_streambuf<Protocol, StreamSocketService,
+          Time, TimeTraits, TimerService> >::member)
+  {
+    tie(this);
+    if (rdbuf()->connect(x...) == 0)
+      this->setstate(std::ios_base::failbit);
+  }
 #else
   BOOST_PP_REPEAT_FROM_TO(
       1, BOOST_PP_INC(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY),
@@ -118,6 +150,13 @@ public:
    */
   template <typename T1, ..., typename TN>
   void connect(T1 t1, ..., TN tn);
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  template <typename... T>
+  void connect(T... x)
+  {
+    if (rdbuf()->connect(x...) == 0)
+      this->setstate(std::ios_base::failbit);
+  }
 #else
   BOOST_PP_REPEAT_FROM_TO(
       1, BOOST_PP_INC(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY),
@@ -132,11 +171,77 @@ public:
   }
 
   /// Return a pointer to the underlying streambuf.
-  basic_socket_streambuf<Protocol, StreamSocketService>* rdbuf() const
+  basic_socket_streambuf<Protocol, StreamSocketService,
+    Time, TimeTraits, TimerService>* rdbuf() const
   {
-    return const_cast<basic_socket_streambuf<Protocol, StreamSocketService>*>(
+    return const_cast<basic_socket_streambuf<Protocol, StreamSocketService,
+      Time, TimeTraits, TimerService>*>(
         &this->boost::base_from_member<
-          basic_socket_streambuf<Protocol, StreamSocketService> >::member);
+          basic_socket_streambuf<Protocol, StreamSocketService,
+            Time, TimeTraits, TimerService> >::member);
+  }
+
+  /// Get the last error associated with the stream.
+  /**
+   * @return An \c error_code corresponding to the last error from the stream.
+   *
+   * @par Example
+   * To print the error associated with a failure to establish a connection:
+   * @code tcp::iostream s("www.boost.org", "http");
+   * if (!s)
+   * {
+   *   std::cout << "Error: " << s.error().message() << std::endl;
+   * } @endcode
+   */
+  const boost::system::error_code& error() const
+  {
+    return rdbuf()->puberror();
+  }
+
+  /// Get the stream's expiry time as an absolute time.
+  /**
+   * @return An absolute time value representing the stream's expiry time.
+   */
+  time_type expires_at() const
+  {
+    return rdbuf()->expires_at();
+  }
+
+  /// Set the stream's expiry time as an absolute time.
+  /**
+   * This function sets the expiry time associated with the stream. Stream
+   * operations performed after this time (where the operations cannot be
+   * completed using the internal buffers) will fail with the error
+   * boost::asio::error::operation_aborted.
+   *
+   * @param expiry_time The expiry time to be used for the stream.
+   */
+  void expires_at(const time_type& expiry_time)
+  {
+    rdbuf()->expires_at(expiry_time);
+  }
+
+  /// Get the timer's expiry time relative to now.
+  /**
+   * @return A relative time value representing the stream's expiry time.
+   */
+  duration_type expires_from_now() const
+  {
+    return rdbuf()->expires_from_now();
+  }
+
+  /// Set the stream's expiry time relative to now.
+  /**
+   * This function sets the expiry time associated with the stream. Stream
+   * operations performed after this time (where the operations cannot be
+   * completed using the internal buffers) will fail with the error
+   * boost::asio::error::operation_aborted.
+   *
+   * @param expiry_time The expiry time to be used for the timer.
+   */
+  void expires_from_now(const duration_type& expiry_time)
+  {
+    rdbuf()->expires_from_now(expiry_time);
   }
 };
 
@@ -145,8 +250,10 @@ public:
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#undef BOOST_ASIO_PRIVATE_CTR_DEF
-#undef BOOST_ASIO_PRIVATE_CONNECT_DEF
+#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+# undef BOOST_ASIO_PRIVATE_CTR_DEF
+# undef BOOST_ASIO_PRIVATE_CONNECT_DEF
+#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 #endif // defined(BOOST_NO_IOSTREAM)
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
index c2a9a99..ff1e268 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
@@ -20,53 +20,64 @@
 #if !defined(BOOST_NO_IOSTREAM)
 
 #include <streambuf>
-#include <boost/array.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/utility/base_from_member.hpp>
 #include <boost/asio/basic_socket.hpp>
+#include <boost/asio/deadline_timer_service.hpp>
+#include <boost/asio/detail/array.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/stream_socket_service.hpp>
+#include <boost/asio/time_traits.hpp>
 
-#if !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
-#define BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY 5
-#endif // !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+# include <boost/preprocessor/arithmetic/inc.hpp>
+# include <boost/preprocessor/repetition/enum_binary_params.hpp>
+# include <boost/preprocessor/repetition/enum_params.hpp>
+# include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+# if !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
+#  define BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY 5
+# endif // !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
-//   basic_socket_streambuf<Protocol, StreamSocketService>* connect(
+//   basic_socket_streambuf<Protocol, StreamSocketService,
+//     Time, TimeTraits, TimerService>* connect(
 //       T1 x1, ..., Tn xn)
 //   {
 //     init_buffers();
-//     boost::system::error_code ec;
-//     this->basic_socket<Protocol, StreamSocketService>::close(ec);
+//     this->basic_socket<Protocol, StreamSocketService>::close(ec_);
 //     typedef typename Protocol::resolver resolver_type;
 //     typedef typename resolver_type::query resolver_query;
 //     resolver_query query(x1, ..., xn);
-//     resolve_and_connect(query, ec);
-//     return !ec ? this : 0;
+//     resolve_and_connect(query);
+//     return !ec_ ? this : 0;
 //   }
 // This macro should only persist within this file.
 
-#define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
+# define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
   template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
-  basic_socket_streambuf<Protocol, StreamSocketService>* connect( \
+  basic_socket_streambuf<Protocol, StreamSocketService, \
+    Time, TimeTraits, TimerService>* connect( \
       BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
   { \
     init_buffers(); \
-    boost::system::error_code ec; \
-    this->basic_socket<Protocol, StreamSocketService>::close(ec); \
+    this->basic_socket<Protocol, StreamSocketService>::close(ec_); \
     typedef typename Protocol::resolver resolver_type; \
     typedef typename resolver_type::query resolver_query; \
     resolver_query query(BOOST_PP_ENUM_PARAMS(n, x)); \
-    resolve_and_connect(query, ec); \
-    return !ec ? this : 0; \
+    resolve_and_connect(query); \
+    return !ec_ ? this : 0; \
   } \
   /**/
 
+#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -74,7 +85,10 @@ namespace asio {
 
 /// Iostream streambuf for a socket.
 template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol> >
+    typename StreamSocketService = stream_socket_service<Protocol>,
+    typename Time = boost::posix_time::ptime,
+    typename TimeTraits = boost::asio::time_traits<Time>,
+    typename TimerService = deadline_timer_service<Time, TimeTraits> >
 class basic_socket_streambuf
   : public std::streambuf,
     private boost::base_from_member<io_service>,
@@ -84,11 +98,19 @@ public:
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
+  /// The time type.
+  typedef typename TimeTraits::time_type time_type;
+
+  /// The duration type.
+  typedef typename TimeTraits::duration_type duration_type;
+
   /// Construct a basic_socket_streambuf without establishing a connection.
   basic_socket_streambuf()
     : basic_socket<Protocol, StreamSocketService>(
         boost::base_from_member<boost::asio::io_service>::member),
-      unbuffered_(false)
+      unbuffered_(false),
+      timer_service_(0),
+      timer_state_(no_timer)
   {
     init_buffers();
   }
@@ -98,6 +120,8 @@ public:
   {
     if (pptr() != pbase())
       overflow(traits_type::eof());
+
+    destroy_timer();
   }
 
   /// Establish a connection.
@@ -107,14 +131,30 @@ public:
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
    */
-  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
+  basic_socket_streambuf<Protocol, StreamSocketService,
+    Time, TimeTraits, TimerService>* connect(
       const endpoint_type& endpoint)
   {
     init_buffers();
-    boost::system::error_code ec;
-    this->basic_socket<Protocol, StreamSocketService>::close(ec);
-    this->basic_socket<Protocol, StreamSocketService>::connect(endpoint, ec);
-    return !ec ? this : 0;
+
+    this->basic_socket<Protocol, StreamSocketService>::close(ec_);
+
+    if (timer_state_ == timer_has_expired)
+    {
+      ec_ = boost::asio::error::operation_aborted;
+      return 0;
+    }
+
+    io_handler handler = { this };
+    this->basic_socket<Protocol, StreamSocketService>::async_connect(
+        endpoint, handler);
+
+    ec_ = boost::asio::error::would_block;
+    this->get_service().get_io_service().reset();
+    do this->get_service().get_io_service().run_one();
+    while (ec_ == boost::asio::error::would_block);
+
+    return !ec_ ? this : 0;
   }
 
 #if defined(GENERATING_DOCUMENTATION)
@@ -130,6 +170,19 @@ public:
   template <typename T1, ..., typename TN>
   basic_socket_streambuf<Protocol, StreamSocketService>* connect(
       T1 t1, ..., TN tn);
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  template <typename... T>
+  basic_socket_streambuf<Protocol, StreamSocketService,
+    Time, TimeTraits, TimerService>* connect(T... x)
+  {
+    init_buffers();
+    this->basic_socket<Protocol, StreamSocketService>::close(ec_);
+    typedef typename Protocol::resolver resolver_type;
+    typedef typename resolver_type::query resolver_query;
+    resolver_query query(x...);
+    resolve_and_connect(query);
+    return !ec_ ? this : 0;
+  }
 #else
   BOOST_PP_REPEAT_FROM_TO(
       1, BOOST_PP_INC(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY),
@@ -141,14 +194,85 @@ public:
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
    */
-  basic_socket_streambuf<Protocol, StreamSocketService>* close()
+  basic_socket_streambuf<Protocol, StreamSocketService,
+    Time, TimeTraits, TimerService>* close()
   {
-    boost::system::error_code ec;
     sync();
-    this->basic_socket<Protocol, StreamSocketService>::close(ec);
-    if (!ec)
+    this->basic_socket<Protocol, StreamSocketService>::close(ec_);
+    if (!ec_)
       init_buffers();
-    return !ec ? this : 0;
+    return !ec_ ? this : 0;
+  }
+
+  /// Get the last error associated with the stream buffer.
+  /**
+   * @return An \c error_code corresponding to the last error from the stream
+   * buffer.
+   */
+  const boost::system::error_code& puberror() const
+  {
+    return error();
+  }
+
+  /// Get the stream buffer's expiry time as an absolute time.
+  /**
+   * @return An absolute time value representing the stream buffer's expiry
+   * time.
+   */
+  time_type expires_at() const
+  {
+    return timer_service_
+      ? timer_service_->expires_at(timer_implementation_)
+      : time_type();
+  }
+
+  /// Set the stream buffer's expiry time as an absolute time.
+  /**
+   * This function sets the expiry time associated with the stream. Stream
+   * operations performed after this time (where the operations cannot be
+   * completed using the internal buffers) will fail with the error
+   * boost::asio::error::operation_aborted.
+   *
+   * @param expiry_time The expiry time to be used for the stream.
+   */
+  void expires_at(const time_type& expiry_time)
+  {
+    construct_timer();
+
+    boost::system::error_code ec;
+    timer_service_->expires_at(timer_implementation_, expiry_time, ec);
+    boost::asio::detail::throw_error(ec, "expires_at");
+
+    start_timer();
+  }
+
+  /// Get the stream buffer's expiry time relative to now.
+  /**
+   * @return A relative time value representing the stream buffer's expiry time.
+   */
+  duration_type expires_from_now() const
+  {
+    return TimeTraits::subtract(expires_at(), TimeTraits::now());
+  }
+
+  /// Set the stream buffer's expiry time relative to now.
+  /**
+   * This function sets the expiry time associated with the stream. Stream
+   * operations performed after this time (where the operations cannot be
+   * completed using the internal buffers) will fail with the error
+   * boost::asio::error::operation_aborted.
+   *
+   * @param expiry_time The expiry time to be used for the timer.
+   */
+  void expires_from_now(const duration_type& expiry_time)
+  {
+    construct_timer();
+
+    boost::system::error_code ec;
+    timer_service_->expires_from_now(timer_implementation_, expiry_time, ec);
+    boost::asio::detail::throw_error(ec, "expires_from_now");
+
+    start_timer();
   }
 
 protected:
@@ -156,15 +280,26 @@ protected:
   {
     if (gptr() == egptr())
     {
-      boost::system::error_code ec;
-      std::size_t bytes_transferred = this->service.receive(
-          this->implementation,
+      if (timer_state_ == timer_has_expired)
+      {
+        ec_ = boost::asio::error::operation_aborted;
+        return traits_type::eof();
+      }
+
+      io_handler handler = { this };
+      this->get_service().async_receive(this->get_implementation(),
           boost::asio::buffer(boost::asio::buffer(get_buffer_) + putback_max),
-          0, ec);
-      if (ec)
+          0, handler);
+
+      ec_ = boost::asio::error::would_block;
+      this->get_service().get_io_service().reset();
+      do this->get_service().get_io_service().run_one();
+      while (ec_ == boost::asio::error::would_block);
+      if (ec_)
         return traits_type::eof();
-      setg(get_buffer_.begin(), get_buffer_.begin() + putback_max,
-          get_buffer_.begin() + putback_max + bytes_transferred);
+
+      setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
+          &get_buffer_[0] + putback_max + bytes_transferred_);
       return traits_type::to_int_type(*gptr());
     }
     else
@@ -184,13 +319,25 @@ protected:
       }
       else
       {
+        if (timer_state_ == timer_has_expired)
+        {
+          ec_ = boost::asio::error::operation_aborted;
+          return traits_type::eof();
+        }
+
         // Send the single character immediately.
-        boost::system::error_code ec;
         char_type ch = traits_type::to_char_type(c);
-        this->service.send(this->implementation,
-            boost::asio::buffer(&ch, sizeof(char_type)), 0, ec);
-        if (ec)
+        io_handler handler = { this };
+        this->get_service().async_send(this->get_implementation(),
+            boost::asio::buffer(&ch, sizeof(char_type)), 0, handler);
+
+        ec_ = boost::asio::error::would_block;
+        this->get_service().get_io_service().reset();
+        do this->get_service().get_io_service().run_one();
+        while (ec_ == boost::asio::error::would_block);
+        if (ec_)
           return traits_type::eof();
+
         return c;
       }
     }
@@ -201,15 +348,26 @@ protected:
         boost::asio::buffer(pbase(), pptr() - pbase());
       while (boost::asio::buffer_size(buffer) > 0)
       {
-        boost::system::error_code ec;
-        std::size_t bytes_transferred = this->service.send(
-            this->implementation, boost::asio::buffer(buffer),
-            0, ec);
-        if (ec)
+        if (timer_state_ == timer_has_expired)
+        {
+          ec_ = boost::asio::error::operation_aborted;
+          return traits_type::eof();
+        }
+
+        io_handler handler = { this };
+        this->get_service().async_send(this->get_implementation(),
+            boost::asio::buffer(buffer), 0, handler);
+
+        ec_ = boost::asio::error::would_block;
+        this->get_service().get_io_service().reset();
+        do this->get_service().get_io_service().run_one();
+        while (ec_ == boost::asio::error::would_block);
+        if (ec_)
           return traits_type::eof();
-        buffer = buffer + bytes_transferred;
+
+        buffer = buffer + bytes_transferred_;
       }
-      setp(put_buffer_.begin(), put_buffer_.end());
+      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
 
       // If the new character is eof then our work here is done.
       if (traits_type::eq_int_type(c, traits_type::eof()))
@@ -239,45 +397,141 @@ protected:
     return 0;
   }
 
+  /// Get the last error associated with the stream buffer.
+  /**
+   * @return An \c error_code corresponding to the last error from the stream
+   * buffer.
+   */
+  virtual const boost::system::error_code& error() const
+  {
+    return ec_;
+  }
+
 private:
   void init_buffers()
   {
-    setg(get_buffer_.begin(),
-        get_buffer_.begin() + putback_max,
-        get_buffer_.begin() + putback_max);
+    setg(&get_buffer_[0],
+        &get_buffer_[0] + putback_max,
+        &get_buffer_[0] + putback_max);
     if (unbuffered_)
       setp(0, 0);
     else
-      setp(put_buffer_.begin(), put_buffer_.end());
+      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
   }
 
   template <typename ResolverQuery>
-  void resolve_and_connect(const ResolverQuery& query,
-      boost::system::error_code& ec)
+  void resolve_and_connect(const ResolverQuery& query)
   {
     typedef typename Protocol::resolver resolver_type;
     typedef typename resolver_type::iterator iterator_type;
     resolver_type resolver(
         boost::base_from_member<boost::asio::io_service>::member);
-    iterator_type i = resolver.resolve(query, ec);
-    if (!ec)
+    iterator_type i = resolver.resolve(query, ec_);
+    if (!ec_)
     {
       iterator_type end;
-      ec = boost::asio::error::host_not_found;
-      while (ec && i != end)
+      ec_ = boost::asio::error::host_not_found;
+      while (ec_ && i != end)
       {
-        this->basic_socket<Protocol, StreamSocketService>::close();
-        this->basic_socket<Protocol, StreamSocketService>::connect(*i, ec);
+        this->basic_socket<Protocol, StreamSocketService>::close(ec_);
+
+        if (timer_state_ == timer_has_expired)
+        {
+          ec_ = boost::asio::error::operation_aborted;
+          return;
+        }
+
+        io_handler handler = { this };
+        this->basic_socket<Protocol, StreamSocketService>::async_connect(
+            *i, handler);
+
+        ec_ = boost::asio::error::would_block;
+        this->get_service().get_io_service().reset();
+        do this->get_service().get_io_service().run_one();
+        while (ec_ == boost::asio::error::would_block);
+
         ++i;
       }
     }
   }
 
+  struct io_handler;
+  friend struct io_handler;
+  struct io_handler
+  {
+    basic_socket_streambuf* this_;
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred = 0)
+    {
+      this_->ec_ = ec;
+      this_->bytes_transferred_ = bytes_transferred;
+    }
+  };
+
+  struct timer_handler;
+  friend struct timer_handler;
+  struct timer_handler
+  {
+    basic_socket_streambuf* this_;
+
+    void operator()(const boost::system::error_code&)
+    {
+      time_type now = TimeTraits::now();
+
+      time_type expiry_time = this_->timer_service_->expires_at(
+            this_->timer_implementation_);
+
+      if (TimeTraits::less_than(now, expiry_time))
+      {
+        this_->timer_state_ = timer_is_pending;
+        this_->timer_service_->async_wait(this_->timer_implementation_, *this);
+      }
+      else
+      {
+        this_->timer_state_ = timer_has_expired;
+        boost::system::error_code ec;
+        this_->basic_socket<Protocol, StreamSocketService>::close(ec);
+      }
+    }
+  };
+
+  void construct_timer()
+  {
+    if (timer_service_ == 0)
+    {
+      TimerService& timer_service = use_service<TimerService>(
+          boost::base_from_member<boost::asio::io_service>::member);
+      timer_service.construct(timer_implementation_);
+      timer_service_ = &timer_service;
+    }
+  }
+
+  void destroy_timer()
+  {
+    if (timer_service_)
+      timer_service_->destroy(timer_implementation_);
+  }
+
+  void start_timer()
+  {
+    if (timer_state_ != timer_is_pending)
+    {
+      timer_handler handler = { this };
+      handler(boost::system::error_code());
+    }
+  }
+
   enum { putback_max = 8 };
   enum { buffer_size = 512 };
-  boost::array<char, buffer_size> get_buffer_;
-  boost::array<char, buffer_size> put_buffer_;
+  boost::asio::detail::array<char, buffer_size> get_buffer_;
+  boost::asio::detail::array<char, buffer_size> put_buffer_;
   bool unbuffered_;
+  boost::system::error_code ec_;
+  std::size_t bytes_transferred_;
+  TimerService* timer_service_;
+  typename TimerService::implementation_type timer_implementation_;
+  enum state { no_timer, timer_is_pending, timer_has_expired } timer_state_;
 };
 
 } // namespace asio
@@ -285,7 +539,9 @@ private:
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#undef BOOST_ASIO_PRIVATE_CONNECT_DEF
+#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+# undef BOOST_ASIO_PRIVATE_CONNECT_DEF
+#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
index 87bd035..728e8db 100644
--- a/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
@@ -18,6 +18,7 @@
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <boost/asio/basic_socket.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/stream_socket_service.hpp>
@@ -45,8 +46,12 @@ class basic_stream_socket
   : public basic_socket<Protocol, StreamSocketService>
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// socket.
+  typedef typename StreamSocketService::native_handle_type native_type;
+
   /// The native representation of a socket.
-  typedef typename StreamSocketService::native_type native_type;
+  typedef typename StreamSocketService::native_handle_type native_handle_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -122,12 +127,47 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_socket)
+      const protocol_type& protocol, const native_handle_type& native_socket)
     : basic_socket<Protocol, StreamSocketService>(
         io_service, protocol, native_socket)
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_stream_socket from another.
+  /**
+   * This constructor moves a stream socket from one object to another.
+   *
+   * @param other The other basic_stream_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_socket(io_service&) constructor.
+   */
+  basic_stream_socket(basic_stream_socket&& other)
+    : basic_socket<Protocol, StreamSocketService>(
+        BOOST_ASIO_MOVE_CAST(basic_stream_socket)(other))
+  {
+  }
+
+  /// Move-assign a basic_stream_socket from another.
+  /**
+   * This assignment operator moves a stream socket from one object to another.
+   *
+   * @param other The other basic_stream_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_socket(io_service&) constructor.
+   */
+  basic_stream_socket& operator=(basic_stream_socket&& other)
+  {
+    basic_socket<Protocol, StreamSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_stream_socket)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Send some data on the socket.
   /**
    * This function is used to send data on the stream socket. The function
@@ -157,9 +197,9 @@ public:
   std::size_t send(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "send");
     return s;
   }
 
@@ -195,9 +235,9 @@ public:
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
+    boost::asio::detail::throw_error(ec, "send");
     return s;
   }
 
@@ -223,7 +263,8 @@ public:
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->service.send(this->implementation, buffers, flags, ec);
+    return this->get_service().send(
+        this->get_implementation(), buffers, flags, ec);
   }
 
   /// Start an asynchronous send.
@@ -262,9 +303,15 @@ public:
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers, WriteHandler handler)
+  void async_send(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(), buffers, 0,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send.
@@ -306,9 +353,15 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send(this->implementation, buffers, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(), buffers, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data on the socket.
@@ -343,8 +396,9 @@ public:
   std::size_t receive(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive(this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "receive");
     return s;
   }
 
@@ -383,9 +437,9 @@ public:
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, flags, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, flags, ec);
+    boost::asio::detail::throw_error(ec, "receive");
     return s;
   }
 
@@ -411,7 +465,8 @@ public:
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->service.receive(this->implementation, buffers, flags, ec);
+    return this->get_service().receive(
+        this->get_implementation(), buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
@@ -452,9 +507,15 @@ public:
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers, ReadHandler handler)
+  void async_receive(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive.
@@ -498,9 +559,15 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive(this->implementation, buffers, flags, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Write some data to the socket.
@@ -534,8 +601,9 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().send(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
     return s;
   }
 
@@ -559,7 +627,7 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.send(this->implementation, buffers, 0, ec);
+    return this->get_service().send(this->get_implementation(), buffers, 0, ec);
   }
 
   /// Start an asynchronous write.
@@ -599,9 +667,14 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_send(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the socket.
@@ -636,8 +709,9 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.receive(this->implementation, buffers, 0, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().receive(
+        this->get_implementation(), buffers, 0, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
     return s;
   }
 
@@ -662,7 +736,8 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.receive(this->implementation, buffers, 0, ec);
+    return this->get_service().receive(
+        this->get_implementation(), buffers, 0, ec);
   }
 
   /// Start an asynchronous read.
@@ -703,9 +778,14 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
index 7a04c69..6e64289 100644
--- a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
@@ -130,9 +130,9 @@ public:
    * of the streambuf's input sequence is 0.
    */
   explicit basic_streambuf(
-      std::size_t max_size = (std::numeric_limits<std::size_t>::max)(),
+      std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
       const Allocator& allocator = Allocator())
-    : max_size_(max_size),
+    : max_size_(maximum_size),
       buffer_(allocator)
   {
     std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
diff --git a/3rdParty/Boost/src/boost/asio/buffer.hpp b/3rdParty/Boost/src/boost/asio/buffer.hpp
index 15eaad4..5f36570 100644
--- a/3rdParty/Boost/src/boost/asio/buffer.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffer.hpp
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <cstring>
 #include <string>
 #include <vector>
 #include <boost/detail/workaround.hpp>
@@ -68,6 +69,19 @@ std::size_t buffer_size_helper(const const_buffer&);
  * The mutable_buffer class provides a safe representation of a buffer that can
  * be modified. It does not own the underlying data, and so is cheap to copy or
  * assign.
+ *
+ * @par Accessing Buffer Contents
+ *
+ * The contents of a buffer may be accessed using the @ref buffer_size
+ * and @ref buffer_cast functions:
+ *
+ * @code boost::asio::mutable_buffer b1 = ...;
+ * std::size_t s1 = boost::asio::buffer_size(b1);
+ * unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
+ * @endcode
+ *
+ * The boost::asio::buffer_cast function permits violations of type safety, so
+ * uses of it in application code should be carefully considered.
  */
 class mutable_buffer
 {
@@ -133,59 +147,6 @@ inline std::size_t buffer_size_helper(const mutable_buffer& b)
 
 } // namespace detail
 
-/// Cast a non-modifiable buffer to a specified pointer to POD type.
-/**
- * @relates mutable_buffer
- */
-template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const mutable_buffer& b)
-{
-  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
-}
-
-/// Get the number of bytes in a non-modifiable buffer.
-/**
- * @relates mutable_buffer
- */
-inline std::size_t buffer_size(const mutable_buffer& b)
-{
-  return detail::buffer_size_helper(b);
-}
-
-/// Create a new modifiable buffer that is offset from the start of another.
-/**
- * @relates mutable_buffer
- */
-inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
-{
-  if (start > buffer_size(b))
-    return mutable_buffer();
-  char* new_data = buffer_cast<char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return mutable_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new modifiable buffer that is offset from the start of another.
-/**
- * @relates mutable_buffer
- */
-inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
-{
-  if (start > buffer_size(b))
-    return mutable_buffer();
-  char* new_data = buffer_cast<char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return mutable_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
 /// Adapts a single modifiable buffer so that it meets the requirements of the
 /// MutableBufferSequence concept.
 class mutable_buffers_1
@@ -228,6 +189,19 @@ public:
  * The const_buffer class provides a safe representation of a buffer that cannot
  * be modified. It does not own the underlying data, and so is cheap to copy or
  * assign.
+ *
+ * @par Accessing Buffer Contents
+ *
+ * The contents of a buffer may be accessed using the @ref buffer_size
+ * and @ref buffer_cast functions:
+ *
+ * @code boost::asio::const_buffer b1 = ...;
+ * std::size_t s1 = boost::asio::buffer_size(b1);
+ * const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
+ * @endcode
+ *
+ * The boost::asio::buffer_cast function permits violations of type safety, so
+ * uses of it in application code should be carefully considered.
  */
 class const_buffer
 {
@@ -303,59 +277,6 @@ inline std::size_t buffer_size_helper(const const_buffer& b)
 
 } // namespace detail
 
-/// Cast a non-modifiable buffer to a specified pointer to POD type.
-/**
- * @relates const_buffer
- */
-template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const const_buffer& b)
-{
-  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
-}
-
-/// Get the number of bytes in a non-modifiable buffer.
-/**
- * @relates const_buffer
- */
-inline std::size_t buffer_size(const const_buffer& b)
-{
-  return detail::buffer_size_helper(b);
-}
-
-/// Create a new non-modifiable buffer that is offset from the start of another.
-/**
- * @relates const_buffer
- */
-inline const_buffer operator+(const const_buffer& b, std::size_t start)
-{
-  if (start > buffer_size(b))
-    return const_buffer();
-  const char* new_data = buffer_cast<const char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return const_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that is offset from the start of another.
-/**
- * @relates const_buffer
- */
-inline const_buffer operator+(std::size_t start, const const_buffer& b)
-{
-  if (start > buffer_size(b))
-    return const_buffer();
-  const char* new_data = buffer_cast<const char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return const_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
 /// Adapts a single non-modifiable buffer so that it meets the requirements of
 /// the ConstBufferSequence concept.
 class const_buffers_1
@@ -420,6 +341,163 @@ private:
   mutable_buffer buf_;
 };
 
+/** @defgroup buffer_size boost::asio::buffer_size
+ *
+ * @brief The boost::asio::buffer_size function determines the total number of
+ * bytes in a buffer or buffer sequence.
+ */
+/*@{*/
+
+/// Get the number of bytes in a modifiable buffer.
+inline std::size_t buffer_size(const mutable_buffer& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Get the number of bytes in a modifiable buffer.
+inline std::size_t buffer_size(const mutable_buffers_1& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Get the number of bytes in a non-modifiable buffer.
+inline std::size_t buffer_size(const const_buffer& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Get the number of bytes in a non-modifiable buffer.
+inline std::size_t buffer_size(const const_buffers_1& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Get the total number of bytes in a buffer sequence.
+/** 
+ * The @c BufferSequence template parameter may meet either of the @c
+ * ConstBufferSequence or @c MutableBufferSequence type requirements.
+ */
+template <typename BufferSequence>
+inline std::size_t buffer_size(const BufferSequence& b)
+{
+  std::size_t total_buffer_size = 0;
+
+  typename BufferSequence::const_iterator iter = b.begin();
+  typename BufferSequence::const_iterator end = b.end();
+  for (; iter != end; ++iter)
+    total_buffer_size += detail::buffer_size_helper(*iter);
+
+  return total_buffer_size;
+}
+
+/*@}*/
+
+/** @defgroup buffer_cast boost::asio::buffer_cast
+ *
+ * @brief The boost::asio::buffer_cast function is used to obtain a pointer to
+ * the underlying memory region associated with a buffer.
+ *
+ * @par Examples:
+ *
+ * To access the memory of a non-modifiable buffer, use:
+ * @code boost::asio::const_buffer b1 = ...;
+ * const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
+ * @endcode
+ *
+ * To access the memory of a modifiable buffer, use:
+ * @code boost::asio::mutable_buffer b2 = ...;
+ * unsigned char* p2 = boost::asio::buffer_cast<unsigned char*>(b2);
+ * @endcode
+ *
+ * The boost::asio::buffer_cast function permits violations of type safety, so
+ * uses of it in application code should be carefully considered.
+ */
+/*@{*/
+
+/// Cast a non-modifiable buffer to a specified pointer to POD type.
+template <typename PointerToPodType>
+inline PointerToPodType buffer_cast(const mutable_buffer& b)
+{
+  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
+}
+
+/// Cast a non-modifiable buffer to a specified pointer to POD type.
+template <typename PointerToPodType>
+inline PointerToPodType buffer_cast(const const_buffer& b)
+{
+  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
+}
+
+/*@}*/
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_buffer
+ */
+inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
+{
+  if (start > buffer_size(b))
+    return mutable_buffer();
+  char* new_data = buffer_cast<char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return mutable_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_buffer
+ */
+inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
+{
+  if (start > buffer_size(b))
+    return mutable_buffer();
+  char* new_data = buffer_cast<char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return mutable_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_buffer
+ */
+inline const_buffer operator+(const const_buffer& b, std::size_t start)
+{
+  if (start > buffer_size(b))
+    return const_buffer();
+  const char* new_data = buffer_cast<const char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return const_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_buffer
+ */
+inline const_buffer operator+(std::size_t start, const const_buffer& b)
+{
+  if (start > buffer_size(b))
+    return const_buffer();
+  const char* new_data = buffer_cast<const char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return const_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
 namespace detail {
 
@@ -479,9 +557,9 @@ private:
  * passed to the socket's write function. A buffer created for modifiable
  * memory also meets the requirements of the MutableBufferSequence concept.
  *
- * An individual buffer may be created from a builtin array, std::vector or
- * boost::array of POD elements. This helps prevent buffer overruns by
- * automatically determining the size of the buffer:
+ * An individual buffer may be created from a builtin array, std::vector,
+ * std::array or boost::array of POD elements. This helps prevent buffer
+ * overruns by automatically determining the size of the buffer:
  *
  * @code char d1[128];
  * size_t bytes_transferred = sock.receive(boost::asio::buffer(d1));
@@ -489,8 +567,11 @@ private:
  * std::vector<char> d2(128);
  * bytes_transferred = sock.receive(boost::asio::buffer(d2));
  *
- * boost::array<char, 128> d3;
- * bytes_transferred = sock.receive(boost::asio::buffer(d3)); @endcode
+ * std::array<char, 128> d3;
+ * bytes_transferred = sock.receive(boost::asio::buffer(d3));
+ *
+ * boost::array<char, 128> d4;
+ * bytes_transferred = sock.receive(boost::asio::buffer(d4)); @endcode
  *
  * In all three cases above, the buffers created are exactly 128 bytes long.
  * Note that a vector is @e never automatically resized when creating or using
@@ -499,8 +580,8 @@ private:
  *
  * @par Accessing Buffer Contents
  *
- * The contents of a buffer may be accessed using the boost::asio::buffer_size
- * and boost::asio::buffer_cast functions:
+ * The contents of a buffer may be accessed using the @ref buffer_size and
+ * @ref buffer_cast functions:
  *
  * @code boost::asio::mutable_buffer b1 = ...;
  * std::size_t s1 = boost::asio::buffer_size(b1);
@@ -513,6 +594,24 @@ private:
  * The boost::asio::buffer_cast function permits violations of type safety, so
  * uses of it in application code should be carefully considered.
  *
+ * For convenience, the @ref buffer_size function also works on buffer
+ * sequences (that is, types meeting the ConstBufferSequence or
+ * MutableBufferSequence type requirements). In this case, the function returns
+ * the total size of all buffers in the sequence.
+ *
+ * @par Buffer Copying
+ *
+ * The @ref buffer_copy function may be used to copy raw bytes between
+ * individual buffers and buffer sequences.
+ *
+ * In particular, when used with the @ref buffer_size, the @ref buffer_copy
+ * function can be used to linearise a sequence of buffers. For example:
+ *
+ * @code vector<const_buffer> buffers = ...;
+ *
+ * vector<unsigned char> data(boost::asio::buffer_size(buffers));
+ * boost::asio::buffer_copy(boost::asio::buffer(data), buffers); @endcode
+ *
  * @par Buffer Invalidation
  *
  * A buffer object does not have any ownership of the memory it refers to. It
@@ -526,8 +625,8 @@ private:
  * referring to the elements in the sequence (C++ Std, 23.2.4)
  *
  * For the boost::asio::buffer overloads that accept an argument of type
- * std::string, the buffer objects returned are invalidated according to the
- * rules defined for invalidation of references, pointers and iterators
+ * std::basic_string, the buffer objects returned are invalidated according to
+ * the rules defined for invalidation of references, pointers and iterators
  * referring to elements of the sequence (C++ Std, 21.3).
  *
  * @par Buffer Arithmetic
@@ -896,6 +995,103 @@ inline const_buffers_1 buffer(const boost::array<PodType, N>& data,
         ? data.size() * sizeof(PodType) : max_size_in_bytes));
 }
 
+#if defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
+
+/// Create a new modifiable buffer that represents the given POD array.
+/**
+ * @returns A mutable_buffers_1 value equivalent to:
+ * @code mutable_buffers_1(
+ *     data.data(),
+ *     data.size() * sizeof(PodType)); @endcode
+ */
+template <typename PodType, std::size_t N>
+inline mutable_buffers_1 buffer(std::array<PodType, N>& data)
+{
+  return mutable_buffers_1(
+      mutable_buffer(data.data(), data.size() * sizeof(PodType)));
+}
+
+/// Create a new modifiable buffer that represents the given POD array.
+/**
+ * @returns A mutable_buffers_1 value equivalent to:
+ * @code mutable_buffers_1(
+ *     data.data(),
+ *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
+ */
+template <typename PodType, std::size_t N>
+inline mutable_buffers_1 buffer(std::array<PodType, N>& data,
+    std::size_t max_size_in_bytes)
+{
+  return mutable_buffers_1(
+      mutable_buffer(data.data(),
+        data.size() * sizeof(PodType) < max_size_in_bytes
+        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+/**
+ * @returns A const_buffers_1 value equivalent to:
+ * @code const_buffers_1(
+ *     data.data(),
+ *     data.size() * sizeof(PodType)); @endcode
+ */
+template <typename PodType, std::size_t N>
+inline const_buffers_1 buffer(std::array<const PodType, N>& data)
+{
+  return const_buffers_1(
+      const_buffer(data.data(), data.size() * sizeof(PodType)));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+/**
+ * @returns A const_buffers_1 value equivalent to:
+ * @code const_buffers_1(
+ *     data.data(),
+ *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
+ */
+template <typename PodType, std::size_t N>
+inline const_buffers_1 buffer(std::array<const PodType, N>& data,
+    std::size_t max_size_in_bytes)
+{
+  return const_buffers_1(
+      const_buffer(data.data(),
+        data.size() * sizeof(PodType) < max_size_in_bytes
+        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+/**
+ * @returns A const_buffers_1 value equivalent to:
+ * @code const_buffers_1(
+ *     data.data(),
+ *     data.size() * sizeof(PodType)); @endcode
+ */
+template <typename PodType, std::size_t N>
+inline const_buffers_1 buffer(const std::array<PodType, N>& data)
+{
+  return const_buffers_1(
+      const_buffer(data.data(), data.size() * sizeof(PodType)));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+/**
+ * @returns A const_buffers_1 value equivalent to:
+ * @code const_buffers_1(
+ *     data.data(),
+ *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
+ */
+template <typename PodType, std::size_t N>
+inline const_buffers_1 buffer(const std::array<PodType, N>& data,
+    std::size_t max_size_in_bytes)
+{
+  return const_buffers_1(
+      const_buffer(data.data(),
+        data.size() * sizeof(PodType) < max_size_in_bytes
+        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+}
+
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
+
 /// Create a new modifiable buffer that represents the given POD vector.
 /**
  * @returns A mutable_buffers_1 value equivalent to:
@@ -997,16 +1193,20 @@ inline const_buffers_1 buffer(
 
 /// Create a new non-modifiable buffer that represents the given string.
 /**
- * @returns <tt>const_buffers_1(data.data(), data.size())</tt>.
+ * @returns <tt>const_buffers_1(data.data(), data.size() * sizeof(Elem))</tt>.
  *
  * @note The buffer is invalidated by any non-const operation called on the
  * given string object.
  */
-inline const_buffers_1 buffer(const std::string& data)
+template <typename Elem, typename Traits, typename Allocator>
+inline const_buffers_1 buffer(
+    const std::basic_string<Elem, Traits, Allocator>& data)
 {
-  return const_buffers_1(const_buffer(data.data(), data.size()
+  return const_buffers_1(const_buffer(data.data(), data.size() * sizeof(Elem)
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<std::string::const_iterator>(data.begin())
+        , detail::buffer_debug_check<
+            typename std::basic_string<Elem, Traits, Allocator>::const_iterator
+          >(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
@@ -1016,26 +1216,924 @@ inline const_buffers_1 buffer(const std::string& data)
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.data(),
- *     min(data.size(), max_size_in_bytes)); @endcode
+ *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
  *
  * @note The buffer is invalidated by any non-const operation called on the
  * given string object.
  */
-inline const_buffers_1 buffer(const std::string& data,
+template <typename Elem, typename Traits, typename Allocator>
+inline const_buffers_1 buffer(
+    const std::basic_string<Elem, Traits, Allocator>& data,
     std::size_t max_size_in_bytes)
 {
   return const_buffers_1(
       const_buffer(data.data(),
-        data.size() < max_size_in_bytes
-        ? data.size() : max_size_in_bytes
+        data.size() * sizeof(Elem) < max_size_in_bytes
+        ? data.size() * sizeof(Elem) : max_size_in_bytes
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<std::string::const_iterator>(data.begin())
+        , detail::buffer_debug_check<
+            typename std::basic_string<Elem, Traits, Allocator>::const_iterator
+          >(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
 
 /*@}*/
 
+/** @defgroup buffer_copy boost::asio::buffer_copy
+ *
+ * @brief The boost::asio::buffer_copy function is used to copy bytes from a
+ * source buffer (or buffer sequence) to a target buffer (or buffer sequence).
+ *
+ * The @c buffer_copy function is available in two forms:
+ *
+ * @li A 2-argument form: @c buffer_copy(target, source)
+ *
+ * @li A 3-argument form: @c buffer_copy(target, source, max_bytes_to_copy)
+
+ * Both forms return the number of bytes actually copied. The number of bytes
+ * copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c If specified, @c max_bytes_to_copy.
+ *
+ * This prevents buffer overflow, regardless of the buffer sizes used in the
+ * copy operation.
+ */
+/*@{*/
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const const_buffer& source)
+{
+  using namespace std; // For memcpy.
+  std::size_t target_size = buffer_size(target);
+  std::size_t source_size = buffer_size(source);
+  std::size_t n = target_size < source_size ? target_size : source_size;
+  memcpy(buffer_cast<void*>(target), buffer_cast<const void*>(source), n);
+  return n;
+}
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const const_buffers_1& source)
+{
+  return buffer_copy(target, static_cast<const const_buffer&>(source));
+}
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const mutable_buffer& source)
+{
+  return buffer_copy(target, const_buffer(source));
+}
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const mutable_buffers_1& source)
+{
+  return buffer_copy(target, const_buffer(source));
+}
+
+/// Copies bytes from a source buffer sequence to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer sequence representing the memory
+ * regions from which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+template <typename ConstBufferSequence>
+std::size_t buffer_copy(const mutable_buffer& target,
+    const ConstBufferSequence& source)
+{
+  std::size_t total_bytes_copied = 0;
+
+  typename ConstBufferSequence::const_iterator source_iter = source.begin();
+  typename ConstBufferSequence::const_iterator source_end = source.end();
+
+  for (mutable_buffer target_buffer(target);
+      buffer_size(target_buffer) && source_iter != source_end; ++source_iter)
+  {
+    const_buffer source_buffer(*source_iter);
+    std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
+    total_bytes_copied += bytes_copied;
+    target_buffer = target_buffer + bytes_copied;
+  }
+
+  return total_bytes_copied;
+}
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const const_buffer& source)
+{
+  return buffer_copy(static_cast<const mutable_buffer&>(target), source);
+}
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const const_buffers_1& source)
+{
+  return buffer_copy(static_cast<const mutable_buffer&>(target),
+      static_cast<const const_buffer&>(source));
+}
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const mutable_buffer& source)
+{
+  return buffer_copy(static_cast<const mutable_buffer&>(target),
+      const_buffer(source));
+}
+
+/// Copies bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const mutable_buffers_1& source)
+{
+  return buffer_copy(static_cast<const mutable_buffer&>(target),
+      const_buffer(source));
+}
+
+/// Copies bytes from a source buffer sequence to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer sequence representing the memory
+ * regions from which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+template <typename ConstBufferSequence>
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const ConstBufferSequence& source)
+{
+  return buffer_copy(static_cast<const mutable_buffer&>(target), source);
+}
+
+/// Copies bytes from a source buffer to a target buffer sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+template <typename MutableBufferSequence>
+std::size_t buffer_copy(const MutableBufferSequence& target,
+    const const_buffer& source)
+{
+  std::size_t total_bytes_copied = 0;
+
+  typename MutableBufferSequence::const_iterator target_iter = target.begin();
+  typename MutableBufferSequence::const_iterator target_end = target.end();
+
+  for (const_buffer source_buffer(source);
+      buffer_size(source_buffer) && target_iter != target_end; ++target_iter)
+  {
+    mutable_buffer target_buffer(*target_iter);
+    std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
+    total_bytes_copied += bytes_copied;
+    source_buffer = source_buffer + bytes_copied;
+  }
+
+  return total_bytes_copied;
+}
+
+/// Copies bytes from a source buffer to a target buffer sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+template <typename MutableBufferSequence>
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const const_buffers_1& source)
+{
+  return buffer_copy(target, static_cast<const const_buffer&>(source));
+}
+
+/// Copies bytes from a source buffer to a target buffer sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+template <typename MutableBufferSequence>
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const mutable_buffer& source)
+{
+  return buffer_copy(target, const_buffer(source));
+}
+
+/// Copies bytes from a source buffer to a target buffer sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+template <typename MutableBufferSequence>
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const mutable_buffers_1& source)
+{
+  return buffer_copy(target, const_buffer(source));
+}
+
+/// Copies bytes from a source buffer sequence to a target buffer sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer sequence representing the memory
+ * regions from which the bytes will be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ */
+template <typename MutableBufferSequence, typename ConstBufferSequence>
+std::size_t buffer_copy(const MutableBufferSequence& target,
+    const ConstBufferSequence& source)
+{
+  std::size_t total_bytes_copied = 0;
+
+  typename MutableBufferSequence::const_iterator target_iter = target.begin();
+  typename MutableBufferSequence::const_iterator target_end = target.end();
+  std::size_t target_buffer_offset = 0;
+
+  typename ConstBufferSequence::const_iterator source_iter = source.begin();
+  typename ConstBufferSequence::const_iterator source_end = source.end();
+  std::size_t source_buffer_offset = 0;
+
+  while (target_iter != target_end && source_iter != source_end)
+  {
+    mutable_buffer target_buffer =
+      mutable_buffer(*target_iter) + target_buffer_offset;
+
+    const_buffer source_buffer =
+      const_buffer(*source_iter) + source_buffer_offset;
+
+    std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
+    total_bytes_copied += bytes_copied;
+
+    if (bytes_copied == buffer_size(target_buffer))
+    {
+      ++target_iter;
+      target_buffer_offset = 0;
+    }
+    else
+      target_buffer_offset += bytes_copied;
+
+    if (bytes_copied == buffer_size(source_buffer))
+    {
+      ++source_iter;
+      source_buffer_offset = 0;
+    }
+    else
+      source_buffer_offset += bytes_copied;
+  }
+
+  return total_bytes_copied;
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const const_buffer& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const const_buffers_1& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const mutable_buffer& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer sequence to a target
+/// buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer sequence representing the memory
+ * regions from which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+template <typename ConstBufferSequence>
+inline std::size_t buffer_copy(const mutable_buffer& target,
+    const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const const_buffer& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const const_buffers_1& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const mutable_buffer& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer sequence to a target
+/// buffer.
+/**
+ * @param target A modifiable buffer representing the memory region to which
+ * the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer sequence representing the memory
+ * regions from which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+template <typename ConstBufferSequence>
+inline std::size_t buffer_copy(const mutable_buffers_1& target,
+    const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer
+/// sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+template <typename MutableBufferSequence>
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const const_buffer& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer
+/// sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer representing the memory region from
+ * which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+template <typename MutableBufferSequence>
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const const_buffers_1& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer
+/// sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+template <typename MutableBufferSequence>
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const mutable_buffer& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+}
+
+/// Copies a limited number of bytes from a source buffer to a target buffer
+/// sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A modifiable buffer representing the memory region from which
+ * the bytes will be copied. The contents of the source buffer will not be
+ * modified.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+template <typename MutableBufferSequence>
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
+{
+  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+}
+
+/// Copies a limited number of bytes from a source buffer sequence to a target
+/// buffer sequence.
+/**
+ * @param target A modifiable buffer sequence representing the memory regions to
+ * which the bytes will be copied.
+ *
+ * @param source A non-modifiable buffer sequence representing the memory
+ * regions from which the bytes will be copied.
+ *
+ * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ *
+ * @returns The number of bytes copied.
+ *
+ * @note The number of bytes copied is the lesser of:
+ *
+ * @li @c buffer_size(target)
+ *
+ * @li @c buffer_size(source)
+ *
+ * @li @c max_bytes_to_copy
+ */
+template <typename MutableBufferSequence, typename ConstBufferSequence>
+std::size_t buffer_copy(const MutableBufferSequence& target,
+    const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
+{
+  std::size_t total_bytes_copied = 0;
+
+  typename MutableBufferSequence::const_iterator target_iter = target.begin();
+  typename MutableBufferSequence::const_iterator target_end = target.end();
+  std::size_t target_buffer_offset = 0;
+
+  typename ConstBufferSequence::const_iterator source_iter = source.begin();
+  typename ConstBufferSequence::const_iterator source_end = source.end();
+  std::size_t source_buffer_offset = 0;
+
+  while (total_bytes_copied != max_bytes_to_copy
+      && target_iter != target_end && source_iter != source_end)
+  {
+    mutable_buffer target_buffer =
+      mutable_buffer(*target_iter) + target_buffer_offset;
+
+    const_buffer source_buffer =
+      const_buffer(*source_iter) + source_buffer_offset;
+
+    std::size_t bytes_copied = buffer_copy(target_buffer,
+        source_buffer, max_bytes_to_copy - total_bytes_copied);
+    total_bytes_copied += bytes_copied;
+
+    if (bytes_copied == buffer_size(target_buffer))
+    {
+      ++target_iter;
+      target_buffer_offset = 0;
+    }
+    else
+      target_buffer_offset += bytes_copied;
+
+    if (bytes_copied == buffer_size(source_buffer))
+    {
+      ++source_iter;
+      source_buffer_offset = 0;
+    }
+    else
+      source_buffer_offset += bytes_copied;
+  }
+
+  return total_bytes_copied;
+}
+
+/*@}*/
+
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp b/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
index af24dd6..b9a3f47 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
@@ -17,7 +17,6 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <cstring>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/asio/buffered_read_stream_fwd.hpp>
 #include <boost/asio/buffer.hpp>
@@ -97,13 +96,6 @@ public:
     return next_layer_.lowest_layer();
   }
 
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  boost::asio::io_service& io_service()
-  {
-    return next_layer_.get_io_service();
-  }
-
   /// Get the io_service associated with the object.
   boost::asio::io_service& get_io_service()
   {
@@ -227,16 +219,7 @@ public:
   template <typename MutableBufferSequence>
   std::size_t read_some(const MutableBufferSequence& buffers)
   {
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      boost::asio::mutable_buffer buffer(*iter);
-      total_buffer_size += boost::asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
+    if (boost::asio::buffer_size(buffers) == 0)
       return 0;
 
     if (storage_.empty())
@@ -253,16 +236,7 @@ public:
   {
     ec = boost::system::error_code();
 
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      boost::asio::mutable_buffer buffer(*iter);
-      total_buffer_size += boost::asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
+    if (boost::asio::buffer_size(buffers) == 0)
       return 0;
 
     if (storage_.empty() && !fill(ec))
@@ -294,24 +268,8 @@ public:
       }
       else
       {
-        using namespace std; // For memcpy.
-
-        std::size_t bytes_avail = storage_.size();
-        std::size_t bytes_copied = 0;
-
-        typename MutableBufferSequence::const_iterator iter = buffers_.begin();
-        typename MutableBufferSequence::const_iterator end = buffers_.end();
-        for (; iter != end && bytes_avail > 0; ++iter)
-        {
-          std::size_t max_length = buffer_size(*iter);
-          std::size_t length = (max_length < bytes_avail)
-            ? max_length : bytes_avail;
-          memcpy(buffer_cast<void*>(*iter),
-              storage_.data() + bytes_copied, length);
-          bytes_copied += length;
-          bytes_avail -= length;
-        }
-
+        std::size_t bytes_copied = boost::asio::buffer_copy(
+            buffers_, storage_.data(), storage_.size());
         storage_.consume(bytes_copied);
         io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
       }
@@ -330,16 +288,7 @@ public:
   void async_read_some(const MutableBufferSequence& buffers,
       ReadHandler handler)
   {
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      boost::asio::mutable_buffer buffer(*iter);
-      total_buffer_size += boost::asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
+    if (boost::asio::buffer_size(buffers) == 0)
     {
       get_io_service().post(detail::bind_handler(
             handler, boost::system::error_code(), 0));
@@ -398,23 +347,8 @@ private:
   template <typename MutableBufferSequence>
   std::size_t copy(const MutableBufferSequence& buffers)
   {
-    using namespace std; // For memcpy.
-
-    std::size_t bytes_avail = storage_.size();
-    std::size_t bytes_copied = 0;
-
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    for (; iter != end && bytes_avail > 0; ++iter)
-    {
-      std::size_t max_length = buffer_size(*iter);
-      std::size_t length = (max_length < bytes_avail)
-        ? max_length : bytes_avail;
-      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
-      bytes_copied += length;
-      bytes_avail -= length;
-    }
-
+    std::size_t bytes_copied = boost::asio::buffer_copy(
+        buffers, storage_.data(), storage_.size());
     storage_.consume(bytes_copied);
     return bytes_copied;
   }
@@ -425,24 +359,7 @@ private:
   template <typename MutableBufferSequence>
   std::size_t peek_copy(const MutableBufferSequence& buffers)
   {
-    using namespace std; // For memcpy.
-
-    std::size_t bytes_avail = storage_.size();
-    std::size_t bytes_copied = 0;
-
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    for (; iter != end && bytes_avail > 0; ++iter)
-    {
-      std::size_t max_length = buffer_size(*iter);
-      std::size_t length = (max_length < bytes_avail)
-        ? max_length : bytes_avail;
-      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
-      bytes_copied += length;
-      bytes_avail -= length;
-    }
-
-    return bytes_copied;
+    return boost::asio::buffer_copy(buffers, storage_.data(), storage_.size());
   }
 
   /// The next layer.
diff --git a/3rdParty/Boost/src/boost/asio/buffered_stream.hpp b/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
index 43d21de..e9cb982 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
@@ -87,13 +87,6 @@ public:
     return stream_impl_.lowest_layer();
   }
 
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  boost::asio::io_service& io_service()
-  {
-    return stream_impl_.get_io_service();
-  }
-
   /// Get the io_service associated with the object.
   boost::asio::io_service& get_io_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp b/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
index a163b13..38928c5 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
@@ -17,7 +17,6 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <cstring>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/asio/buffered_write_stream_fwd.hpp>
 #include <boost/asio/buffer.hpp>
@@ -98,13 +97,6 @@ public:
     return next_layer_.lowest_layer();
   }
 
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  boost::asio::io_service& io_service()
-  {
-    return next_layer_.get_io_service();
-  }
-
   /// Get the io_service associated with the object.
   boost::asio::io_service& get_io_service()
   {
@@ -184,16 +176,7 @@ public:
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers)
   {
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      boost::asio::const_buffer buffer(*iter);
-      total_buffer_size += boost::asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
+    if (boost::asio::buffer_size(buffers) == 0)
       return 0;
 
     if (storage_.size() == storage_.capacity())
@@ -210,16 +193,7 @@ public:
   {
     ec = boost::system::error_code();
 
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      boost::asio::const_buffer buffer(*iter);
-      total_buffer_size += boost::asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
+    if (boost::asio::buffer_size(buffers) == 0)
       return 0;
 
     if (storage_.size() == storage_.capacity() && !flush(ec))
@@ -251,25 +225,14 @@ public:
       }
       else
       {
-        using namespace std; // For memcpy.
-
         std::size_t orig_size = storage_.size();
         std::size_t space_avail = storage_.capacity() - orig_size;
-        std::size_t bytes_copied = 0;
-
-        typename ConstBufferSequence::const_iterator iter = buffers_.begin();
-        typename ConstBufferSequence::const_iterator end = buffers_.end();
-        for (; iter != end && space_avail > 0; ++iter)
-        {
-          std::size_t bytes_avail = buffer_size(*iter);
-          std::size_t length = (bytes_avail < space_avail)
-            ? bytes_avail : space_avail;
-          storage_.resize(orig_size + bytes_copied + length);
-          memcpy(storage_.data() + orig_size + bytes_copied,
-              buffer_cast<const void*>(*iter), length);
-          bytes_copied += length;
-          space_avail -= length;
-        }
+        std::size_t bytes_avail = boost::asio::buffer_size(buffers_);
+        std::size_t length = bytes_avail < space_avail
+          ? bytes_avail : space_avail;
+        storage_.resize(orig_size + length);
+        std::size_t bytes_copied = boost::asio::buffer_copy(
+            storage_.data(), buffers_, length);
 
         io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
       }
@@ -288,16 +251,7 @@ public:
   void async_write_some(const ConstBufferSequence& buffers,
       WriteHandler handler)
   {
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      boost::asio::const_buffer buffer(*iter);
-      total_buffer_size += boost::asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
+    if (boost::asio::buffer_size(buffers) == 0)
     {
       get_io_service().post(detail::bind_handler(
             handler, boost::system::error_code(), 0));
@@ -376,27 +330,12 @@ private:
   template <typename ConstBufferSequence>
   std::size_t copy(const ConstBufferSequence& buffers)
   {
-    using namespace std; // For memcpy.
-
     std::size_t orig_size = storage_.size();
     std::size_t space_avail = storage_.capacity() - orig_size;
-    std::size_t bytes_copied = 0;
-
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    for (; iter != end && space_avail > 0; ++iter)
-    {
-      std::size_t bytes_avail = buffer_size(*iter);
-      std::size_t length = (bytes_avail < space_avail)
-        ? bytes_avail : space_avail;
-      storage_.resize(orig_size + bytes_copied + length);
-      memcpy(storage_.data() + orig_size + bytes_copied,
-          buffer_cast<const void*>(*iter), length);
-      bytes_copied += length;
-      space_avail -= length;
-    }
-
-    return bytes_copied;
+    std::size_t bytes_avail = boost::asio::buffer_size(buffers);
+    std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
+    storage_.resize(orig_size + length);
+    return boost::asio::buffer_copy(storage_.data(), buffers, length);
   }
 
   /// The next layer.
diff --git a/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp b/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
index 3375361..51f5707 100644
--- a/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
@@ -17,9 +17,9 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <iterator>
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/iterator.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/asio/buffer.hpp>
@@ -73,18 +73,47 @@ namespace detail
 /// A random access iterator over the bytes in a buffer sequence.
 template <typename BufferSequence, typename ByteType = char>
 class buffers_iterator
-  : public boost::iterator<
-      std::random_access_iterator_tag,
-      typename detail::buffers_iterator_types<
-        BufferSequence, ByteType>::byte_type>
 {
 private:
   typedef typename detail::buffers_iterator_types<
       BufferSequence, ByteType>::buffer_type buffer_type;
-  typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::byte_type byte_type;
 
 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 ByteType value_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The type of the result of applying operator->() to the iterator.
+  /**
+   * If the buffer sequence stores buffer objects that are convertible to
+   * mutable_buffer, this is a pointer to a non-const ByteType. Otherwise, a
+   * pointer to a const ByteType.
+   */
+  typedef const_or_non_const_ByteType* pointer;
+#else // defined(GENERATING_DOCUMENTATION)
+  typedef typename detail::buffers_iterator_types<
+      BufferSequence, ByteType>::byte_type* pointer;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The type of the result of applying operator*() to the iterator.
+  /**
+   * If the buffer sequence stores buffer objects that are convertible to
+   * mutable_buffer, this is a reference to a non-const ByteType. Otherwise, a
+   * reference to a const ByteType.
+   */
+  typedef const_or_non_const_ByteType& reference;
+#else // defined(GENERATING_DOCUMENTATION)
+  typedef typename detail::buffers_iterator_types<
+      BufferSequence, ByteType>::byte_type& reference;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// The iterator category.
+  typedef std::random_access_iterator_tag iterator_category;
+
   /// Default constructor. Creates an iterator in an undefined state.
   buffers_iterator()
     : current_buffer_(),
@@ -136,19 +165,19 @@ public:
   }
 
   /// Dereference an iterator.
-  byte_type& operator*() const
+  reference operator*() const
   {
     return dereference();
   }
 
   /// Dereference an iterator.
-  byte_type* operator->() const
+  pointer operator->() const
   {
     return &dereference();
   }
 
   /// Access an individual element.
-  byte_type& operator[](std::ptrdiff_t difference) const
+  reference operator[](std::ptrdiff_t difference) const
   {
     buffers_iterator tmp(*this);
     tmp.advance(difference);
@@ -271,9 +300,9 @@ public:
 
 private:
   // Dereference the iterator.
-  byte_type& dereference() const
+  reference dereference() const
   {
-    return buffer_cast<byte_type*>(current_buffer_)[current_buffer_position_];
+    return buffer_cast<pointer>(current_buffer_)[current_buffer_position_];
   }
 
   // Compare two iterators for equality.
diff --git a/3rdParty/Boost/src/boost/asio/completion_condition.hpp b/3rdParty/Boost/src/boost/asio/completion_condition.hpp
index 7f5fc09..ee0579e 100644
--- a/3rdParty/Boost/src/boost/asio/completion_condition.hpp
+++ b/3rdParty/Boost/src/boost/asio/completion_condition.hpp
@@ -76,6 +76,28 @@ private:
   std::size_t minimum_;
 };
 
+class transfer_exactly_t
+{
+public:
+  typedef std::size_t result_type;
+
+  explicit transfer_exactly_t(std::size_t size)
+    : size_(size)
+  {
+  }
+
+  template <typename Error>
+  std::size_t operator()(const Error& err, std::size_t bytes_transferred)
+  {
+    return (!!err || bytes_transferred >= size_) ? 0 :
+      (size_ - bytes_transferred < default_max_transfer_size
+        ? size_ - bytes_transferred : std::size_t(default_max_transfer_size));
+  }
+
+private:
+  std::size_t size_;
+};
+
 } // namespace detail
 
 /**
@@ -154,6 +176,40 @@ inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
 }
 #endif
 
+/// Return a completion condition function object that indicates that a read or
+/// write operation should continue until an exact number of bytes has been
+/// transferred, or until an error occurs.
+/**
+ * This function is used to create an object, of unspecified type, that meets
+ * CompletionCondition requirements.
+ *
+ * @par Example
+ * Reading until a buffer is full or contains exactly 64 bytes:
+ * @code
+ * boost::array<char, 128> buf;
+ * boost::system::error_code ec;
+ * std::size_t n = boost::asio::read(
+ *     sock, boost::asio::buffer(buf),
+ *     boost::asio::transfer_exactly(64), ec);
+ * if (ec)
+ * {
+ *   // An error occurred.
+ * }
+ * else
+ * {
+ *   // n == 64
+ * }
+ * @endcode
+ */
+#if defined(GENERATING_DOCUMENTATION)
+unspecified transfer_exactly(std::size_t size);
+#else
+inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
+{
+  return detail::transfer_exactly_t(size);
+}
+#endif
+
 /*@}*/
 
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/connect.hpp b/3rdParty/Boost/src/boost/asio/connect.hpp
new file mode 100644
index 0000000..760712a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/connect.hpp
@@ -0,0 +1,816 @@
+//
+// connect.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_CONNECT_HPP
+#define BOOST_ASIO_CONNECT_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.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/**
+ * @defgroup connect boost::asio::connect
+ *
+ * @brief Establishes a socket connection by trying each endpoint in a sequence.
+ */
+/*@{*/
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @throws boost::system::system_error Thrown on failure. If the sequence is
+ * empty, the associated @c error_code is boost::asio::error::not_found.
+ * Otherwise, contains the error from the last connection attempt.
+ *
+ * @note This overload assumes that a default constructed object of type @c
+ * Iterator represents the end of the sequence. This is a valid assumption for
+ * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Example
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ * boost::asio::connect(s, r.resolve(q)); @endcode
+ */
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param ec Set to indicate what error occurred, if any. If the sequence is
+ * empty, set to boost::asio::error::not_found. Otherwise, contains the error
+ * from the last connection attempt.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @note This overload assumes that a default constructed object of type @c
+ * Iterator represents the end of the sequence. This is a valid assumption for
+ * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Example
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ * boost::system::error_code ec;
+ * boost::asio::connect(s, r.resolve(q), ec);
+ * if (ec)
+ * {
+ *   // An error occurred.
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, boost::system::error_code& ec);
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param end An iterator pointing to the end of a sequence of endpoints.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @throws boost::system::system_error Thrown on failure. If the sequence is
+ * empty, the associated @c error_code is boost::asio::error::not_found.
+ * Otherwise, contains the error from the last connection attempt.
+ *
+ * @par Example
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::resolver::iterator i = r.resolve(q), end;
+ * tcp::socket s(io_service);
+ * boost::asio::connect(s, i, end); @endcode
+ */
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end);
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param end An iterator pointing to the end of a sequence of endpoints.
+ *
+ * @param ec Set to indicate what error occurred, if any. If the sequence is
+ * empty, set to boost::asio::error::not_found. Otherwise, contains the error
+ * from the last connection attempt.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @par Example
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::resolver::iterator i = r.resolve(q), end;
+ * tcp::socket s(io_service);
+ * boost::system::error_code ec;
+ * boost::asio::connect(s, i, end, ec);
+ * if (ec)
+ * {
+ *   // An error occurred.
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, boost::system::error_code& ec);
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param connect_condition A function object that is called prior to each
+ * connection attempt. The signature of the function object must be:
+ * @code Iterator connect_condition(
+ *     const boost::system::error_code& ec,
+ *     Iterator next); @endcode
+ * The @c ec parameter contains the result from the most recent connect
+ * operation. Before the first connection attempt, @c ec is always set to
+ * indicate success. The @c next parameter is an iterator pointing to the next
+ * endpoint to be tried. The function object should return the next iterator,
+ * but is permitted to return a different iterator so that endpoints may be
+ * skipped. The implementation guarantees that the function object will never
+ * be called with the end iterator.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @throws boost::system::system_error Thrown on failure. If the sequence is
+ * empty, the associated @c error_code is boost::asio::error::not_found.
+ * Otherwise, contains the error from the last connection attempt.
+ *
+ * @note This overload assumes that a default constructed object of type @c
+ * Iterator represents the end of the sequence. This is a valid assumption for
+ * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Example
+ * The following connect condition function object can be used to output
+ * information about the individual connection attempts:
+ * @code struct my_connect_condition
+ * {
+ *   template <typename Iterator>
+ *   Iterator operator()(
+ *       const boost::system::error_code& ec,
+ *       Iterator next)
+ *   {
+ *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
+ *     std::cout << "Trying: " << next->endpoint() << std::endl;
+ *     return next;
+ *   }
+ * }; @endcode
+ * It would be used with the boost::asio::connect function as follows:
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ * tcp::resolver::iterator i = boost::asio::connect(
+ *     s, r.resolve(q), my_connect_condition());
+ * std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
+ */
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, ConnectCondition connect_condition);
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param connect_condition A function object that is called prior to each
+ * connection attempt. The signature of the function object must be:
+ * @code Iterator connect_condition(
+ *     const boost::system::error_code& ec,
+ *     Iterator next); @endcode
+ * The @c ec parameter contains the result from the most recent connect
+ * operation. Before the first connection attempt, @c ec is always set to
+ * indicate success. The @c next parameter is an iterator pointing to the next
+ * endpoint to be tried. The function object should return the next iterator,
+ * but is permitted to return a different iterator so that endpoints may be
+ * skipped. The implementation guarantees that the function object will never
+ * be called with the end iterator.
+ *
+ * @param ec Set to indicate what error occurred, if any. If the sequence is
+ * empty, set to boost::asio::error::not_found. Otherwise, contains the error
+ * from the last connection attempt.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @note This overload assumes that a default constructed object of type @c
+ * Iterator represents the end of the sequence. This is a valid assumption for
+ * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Example
+ * The following connect condition function object can be used to output
+ * information about the individual connection attempts:
+ * @code struct my_connect_condition
+ * {
+ *   template <typename Iterator>
+ *   Iterator operator()(
+ *       const boost::system::error_code& ec,
+ *       Iterator next)
+ *   {
+ *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
+ *     std::cout << "Trying: " << next->endpoint() << std::endl;
+ *     return next;
+ *   }
+ * }; @endcode
+ * It would be used with the boost::asio::connect function as follows:
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ * boost::system::error_code ec;
+ * tcp::resolver::iterator i = boost::asio::connect(
+ *     s, r.resolve(q), my_connect_condition(), ec);
+ * if (ec)
+ * {
+ *   // An error occurred.
+ * }
+ * else
+ * {
+ *   std::cout << "Connected to: " << i->endpoint() << std::endl;
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
+    ConnectCondition connect_condition, boost::system::error_code& ec);
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param end An iterator pointing to the end of a sequence of endpoints.
+ *
+ * @param connect_condition A function object that is called prior to each
+ * connection attempt. The signature of the function object must be:
+ * @code Iterator connect_condition(
+ *     const boost::system::error_code& ec,
+ *     Iterator next); @endcode
+ * The @c ec parameter contains the result from the most recent connect
+ * operation. Before the first connection attempt, @c ec is always set to
+ * indicate success. The @c next parameter is an iterator pointing to the next
+ * endpoint to be tried. The function object should return the next iterator,
+ * but is permitted to return a different iterator so that endpoints may be
+ * skipped. The implementation guarantees that the function object will never
+ * be called with the end iterator.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @throws boost::system::system_error Thrown on failure. If the sequence is
+ * empty, the associated @c error_code is boost::asio::error::not_found.
+ * Otherwise, contains the error from the last connection attempt.
+ *
+ * @par Example
+ * The following connect condition function object can be used to output
+ * information about the individual connection attempts:
+ * @code struct my_connect_condition
+ * {
+ *   template <typename Iterator>
+ *   Iterator operator()(
+ *       const boost::system::error_code& ec,
+ *       Iterator next)
+ *   {
+ *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
+ *     std::cout << "Trying: " << next->endpoint() << std::endl;
+ *     return next;
+ *   }
+ * }; @endcode
+ * It would be used with the boost::asio::connect function as follows:
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::resolver::iterator i = r.resolve(q), end;
+ * tcp::socket s(io_service);
+ * i = boost::asio::connect(s, i, end, my_connect_condition());
+ * std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
+ */
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
+    Iterator end, ConnectCondition connect_condition);
+
+/// Establishes a socket connection by trying each endpoint in a sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c connect member
+ * function, once for each endpoint in the sequence, until a connection is
+ * successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param end An iterator pointing to the end of a sequence of endpoints.
+ *
+ * @param connect_condition A function object that is called prior to each
+ * connection attempt. The signature of the function object must be:
+ * @code Iterator connect_condition(
+ *     const boost::system::error_code& ec,
+ *     Iterator next); @endcode
+ * The @c ec parameter contains the result from the most recent connect
+ * operation. Before the first connection attempt, @c ec is always set to
+ * indicate success. The @c next parameter is an iterator pointing to the next
+ * endpoint to be tried. The function object should return the next iterator,
+ * but is permitted to return a different iterator so that endpoints may be
+ * skipped. The implementation guarantees that the function object will never
+ * be called with the end iterator.
+ *
+ * @param ec Set to indicate what error occurred, if any. If the sequence is
+ * empty, set to boost::asio::error::not_found. Otherwise, contains the error
+ * from the last connection attempt.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @par Example
+ * The following connect condition function object can be used to output
+ * information about the individual connection attempts:
+ * @code struct my_connect_condition
+ * {
+ *   template <typename Iterator>
+ *   Iterator operator()(
+ *       const boost::system::error_code& ec,
+ *       Iterator next)
+ *   {
+ *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
+ *     std::cout << "Trying: " << next->endpoint() << std::endl;
+ *     return next;
+ *   }
+ * }; @endcode
+ * It would be used with the boost::asio::connect function as follows:
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::resolver::iterator i = r.resolve(q), end;
+ * tcp::socket s(io_service);
+ * boost::system::error_code ec;
+ * i = boost::asio::connect(s, i, end, my_connect_condition(), ec);
+ * if (ec)
+ * {
+ *   // An error occurred.
+ * }
+ * else
+ * {
+ *   std::cout << "Connected to: " << i->endpoint() << std::endl;
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition,
+    boost::system::error_code& ec);
+
+/*@}*/
+
+/**
+ * @defgroup async_connect boost::asio::async_connect
+ *
+ * @brief Asynchronously establishes a socket connection by trying each
+ * endpoint in a sequence.
+ */
+/*@{*/
+
+/// Asynchronously establishes a socket connection by trying each endpoint in a
+/// sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c async_connect
+ * member function, once for each endpoint in the sequence, until a connection
+ * is successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param handler The handler to be called when the connect operation
+ * completes. Copies will be made of the handler as required. The function
+ * signature of the handler must be:
+ * @code void handler(
+ *   // Result of operation. if the sequence is empty, set to
+ *   // boost::asio::error::not_found. Otherwise, contains the
+ *   // error from the last connection attempt.
+ *   const boost::system::error_code& error,
+ *
+ *   // On success, an iterator denoting the successfully
+ *   // connected endpoint. Otherwise, the end iterator.
+ *   Iterator iterator
+ * ); @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 This overload assumes that a default constructed object of type @c
+ * Iterator represents the end of the sequence. This is a valid assumption for
+ * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Example
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ *
+ * // ...
+ *
+ * r.async_resolve(q, resolve_handler);
+ *
+ * // ...
+ *
+ * void resolve_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   if (!ec)
+ *   {
+ *     boost::asio::async_connect(s, i, connect_handler);
+ *   }
+ * }
+ *
+ * // ...
+ *
+ * void connect_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   // ...
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ComposedConnectHandler>
+void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+
+/// Asynchronously establishes a socket connection by trying each endpoint in a
+/// sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c async_connect
+ * member function, once for each endpoint in the sequence, until a connection
+ * is successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param end An iterator pointing to the end of a sequence of endpoints.
+ *
+ * @param handler The handler to be called when the connect operation
+ * completes. Copies will be made of the handler as required. The function
+ * signature of the handler must be:
+ * @code void handler(
+ *   // Result of operation. if the sequence is empty, set to
+ *   // boost::asio::error::not_found. Otherwise, contains the
+ *   // error from the last connection attempt.
+ *   const boost::system::error_code& error,
+ *
+ *   // On success, an iterator denoting the successfully
+ *   // connected endpoint. Otherwise, the end iterator.
+ *   Iterator iterator
+ * ); @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().
+ *
+ * @par Example
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ *
+ * // ...
+ *
+ * r.async_resolve(q, resolve_handler);
+ *
+ * // ...
+ *
+ * void resolve_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   if (!ec)
+ *   {
+ *     tcp::resolver::iterator end;
+ *     boost::asio::async_connect(s, i, end, connect_handler);
+ *   }
+ * }
+ *
+ * // ...
+ *
+ * void connect_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   // ...
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ComposedConnectHandler>
+void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+
+/// Asynchronously establishes a socket connection by trying each endpoint in a
+/// sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c async_connect
+ * member function, once for each endpoint in the sequence, until a connection
+ * is successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param connect_condition A function object that is called prior to each
+ * connection attempt. The signature of the function object must be:
+ * @code Iterator connect_condition(
+ *     const boost::system::error_code& ec,
+ *     Iterator next); @endcode
+ * The @c ec parameter contains the result from the most recent connect
+ * operation. Before the first connection attempt, @c ec is always set to
+ * indicate success. The @c next parameter is an iterator pointing to the next
+ * endpoint to be tried. The function object should return the next iterator,
+ * but is permitted to return a different iterator so that endpoints may be
+ * skipped. The implementation guarantees that the function object will never
+ * be called with the end iterator.
+ *
+ * @param handler The handler to be called when the connect operation
+ * completes. Copies will be made of the handler as required. The function
+ * signature of the handler must be:
+ * @code void handler(
+ *   // Result of operation. if the sequence is empty, set to
+ *   // boost::asio::error::not_found. Otherwise, contains the
+ *   // error from the last connection attempt.
+ *   const boost::system::error_code& error,
+ *
+ *   // On success, an iterator denoting the successfully
+ *   // connected endpoint. Otherwise, the end iterator.
+ *   Iterator iterator
+ * ); @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 This overload assumes that a default constructed object of type @c
+ * Iterator represents the end of the sequence. This is a valid assumption for
+ * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Example
+ * The following connect condition function object can be used to output
+ * information about the individual connection attempts:
+ * @code struct my_connect_condition
+ * {
+ *   template <typename Iterator>
+ *   Iterator operator()(
+ *       const boost::system::error_code& ec,
+ *       Iterator next)
+ *   {
+ *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
+ *     std::cout << "Trying: " << next->endpoint() << std::endl;
+ *     return next;
+ *   }
+ * }; @endcode
+ * It would be used with the boost::asio::connect function as follows:
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ *
+ * // ...
+ *
+ * r.async_resolve(q, resolve_handler);
+ *
+ * // ...
+ *
+ * void resolve_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   if (!ec)
+ *   {
+ *     boost::asio::async_connect(s, i,
+ *         my_connect_condition(),
+ *         connect_handler);
+ *   }
+ * }
+ *
+ * // ...
+ *
+ * void connect_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   if (ec)
+ *   {
+ *     // An error occurred.
+ *   }
+ *   else
+ *   {
+ *     std::cout << "Connected to: " << i->endpoint() << std::endl;
+ *   }
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService, typename Iterator,
+    typename ConnectCondition, typename ComposedConnectHandler>
+void async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
+    ConnectCondition connect_condition,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+
+/// Asynchronously establishes a socket connection by trying each endpoint in a
+/// sequence.
+/**
+ * This function attempts to connect a socket to one of a sequence of
+ * endpoints. It does this by repeated calls to the socket's @c async_connect
+ * member function, once for each endpoint in the sequence, until a connection
+ * is successfully established.
+ *
+ * @param s The socket to be connected. If the socket is already open, it will
+ * be closed.
+ *
+ * @param begin An iterator pointing to the start of a sequence of endpoints.
+ *
+ * @param end An iterator pointing to the end of a sequence of endpoints.
+ *
+ * @param connect_condition A function object that is called prior to each
+ * connection attempt. The signature of the function object must be:
+ * @code Iterator connect_condition(
+ *     const boost::system::error_code& ec,
+ *     Iterator next); @endcode
+ * The @c ec parameter contains the result from the most recent connect
+ * operation. Before the first connection attempt, @c ec is always set to
+ * indicate success. The @c next parameter is an iterator pointing to the next
+ * endpoint to be tried. The function object should return the next iterator,
+ * but is permitted to return a different iterator so that endpoints may be
+ * skipped. The implementation guarantees that the function object will never
+ * be called with the end iterator.
+ *
+ * @param handler The handler to be called when the connect operation
+ * completes. Copies will be made of the handler as required. The function
+ * signature of the handler must be:
+ * @code void handler(
+ *   // Result of operation. if the sequence is empty, set to
+ *   // boost::asio::error::not_found. Otherwise, contains the
+ *   // error from the last connection attempt.
+ *   const boost::system::error_code& error,
+ *
+ *   // On success, an iterator denoting the successfully
+ *   // connected endpoint. Otherwise, the end iterator.
+ *   Iterator iterator
+ * ); @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().
+ *
+ * @par Example
+ * The following connect condition function object can be used to output
+ * information about the individual connection attempts:
+ * @code struct my_connect_condition
+ * {
+ *   template <typename Iterator>
+ *   Iterator operator()(
+ *       const boost::system::error_code& ec,
+ *       Iterator next)
+ *   {
+ *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
+ *     std::cout << "Trying: " << next->endpoint() << std::endl;
+ *     return next;
+ *   }
+ * }; @endcode
+ * It would be used with the boost::asio::connect function as follows:
+ * @code tcp::resolver r(io_service);
+ * tcp::resolver::query q("host", "service");
+ * tcp::socket s(io_service);
+ *
+ * // ...
+ *
+ * r.async_resolve(q, resolve_handler);
+ *
+ * // ...
+ *
+ * void resolve_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   if (!ec)
+ *   {
+ *     tcp::resolver::iterator end;
+ *     boost::asio::async_connect(s, i, end,
+ *         my_connect_condition(),
+ *         connect_handler);
+ *   }
+ * }
+ *
+ * // ...
+ *
+ * void connect_handler(
+ *     const boost::system::error_code& ec,
+ *     tcp::resolver::iterator i)
+ * {
+ *   if (ec)
+ *   {
+ *     // An error occurred.
+ *   }
+ *   else
+ *   {
+ *     std::cout << "Connected to: " << i->endpoint() << std::endl;
+ *   }
+ * } @endcode
+ */
+template <typename Protocol, typename SocketService, typename Iterator,
+    typename ConnectCondition, typename ComposedConnectHandler>
+void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+
+/*@}*/
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/connect.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp b/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
index 0db1f34..63a1bf5 100644
--- a/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
@@ -68,11 +68,18 @@ public:
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native socket type.
+  /// (Deprecated: Use native_handle_type.) The native socket type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_type native_type;
+  typedef typename service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native socket type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new datagram socket service for the specified io_service.
@@ -83,18 +90,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new datagram socket implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new datagram socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another datagram socket implementation.
+  void move_assign(implementation_type& impl,
+      datagram_socket_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a datagram socket implementation.
   void destroy(implementation_type& impl)
   {
@@ -114,7 +132,7 @@ public:
 
   /// Assign an existing native socket to a datagram socket.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_type& native_socket,
+      const protocol_type& protocol, const native_handle_type& native_socket,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_socket, ec);
@@ -133,10 +151,16 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native socket implementation.
+  /// (Deprecated: Use native_handle().) Get the native socket implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native socket implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
@@ -177,9 +201,11 @@ public:
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, ConnectHandler handler)
+      const endpoint_type& peer_endpoint,
+      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint, handler);
+    service_impl_.async_connect(impl, peer_endpoint,
+        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
   }
 
   /// Set a socket option.
@@ -206,6 +232,32 @@ public:
     return service_impl_.io_control(impl, command, ec);
   }
 
+  /// Gets the non-blocking mode of the socket.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.non_blocking(impl, mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.native_non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.native_non_blocking(impl, mode, ec);
+  }
+
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
@@ -239,9 +291,11 @@ public:
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send(implementation_type& impl, const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send(impl, buffers, flags, handler);
+    service_impl_.async_send(impl, buffers, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Send a datagram to the specified endpoint.
@@ -257,9 +311,11 @@ public:
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send_to(implementation_type& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send_to(impl, buffers, destination, flags, handler);
+    service_impl_.async_send_to(impl, buffers, destination, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data from the peer.
@@ -275,9 +331,11 @@ public:
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive(impl, buffers, flags, handler);
+    service_impl_.async_receive(impl, buffers, flags,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Receive a datagram with the endpoint of the sender.
@@ -294,13 +352,20 @@ public:
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
     service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
-        handler);
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp b/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
index ce8fd13..80c24ee 100644
--- a/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
@@ -72,12 +72,6 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new timer implementation.
   void construct(implementation_type& impl)
   {
@@ -96,6 +90,13 @@ public:
     return service_impl_.cancel(impl, ec);
   }
 
+  /// Cancels one asynchronous wait operation associated with the timer.
+  std::size_t cancel_one(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return service_impl_.cancel_one(impl, ec);
+  }
+
   /// Get the expiry time for the timer as an absolute time.
   time_type expires_at(const implementation_type& impl) const
   {
@@ -130,12 +131,19 @@ public:
 
   // Start an asynchronous wait on the timer.
   template <typename WaitHandler>
-  void async_wait(implementation_type& impl, WaitHandler handler)
+  void async_wait(implementation_type& impl,
+      BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    service_impl_.async_wait(impl, handler);
+    service_impl_.async_wait(impl, BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/detail/array.hpp b/3rdParty/Boost/src/boost/asio/detail/array.hpp
new file mode 100644
index 0000000..a9b6e43
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/array.hpp
@@ -0,0 +1,40 @@
+//
+// detail/array.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_DETAIL_ARRAY_HPP
+#define BOOST_ASIO_DETAIL_ARRAY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+# include <array>
+#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
+# include <boost/array.hpp>
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+using std::array;
+#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
+using boost::array;
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_ARRAY_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
index b7a27bf..3c8fe5f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/detail/config.hpp>
+
 namespace boost {
 
 template<class T, std::size_t N>
@@ -22,4 +24,11 @@ class array;
 
 } // namespace boost
 
+// Standard library components can't be forward declared, so we'll have to
+// include the array header. Fortunately, it's fairly lightweight and doesn't
+// add significantly to the compile time.
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+# include <array>
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+
 #endif // BOOST_ASIO_DETAIL_ARRAY_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp b/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp
new file mode 100644
index 0000000..943e690
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp
@@ -0,0 +1,40 @@
+//
+// detail/atomic_count.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_DETAIL_ATOMIC_COUNT_HPP
+#define BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_ATOMIC)
+# include <atomic>
+#else // defined(BOOST_ASIO_HAS_STD_ATOMIC)
+# include <boost/detail/atomic_count.hpp>
+#endif // defined(BOOST_ASIO_HAS_STD_ATOMIC)
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_STD_ATOMIC)
+typedef std::atomic<long> atomic_count;
+#else // defined(BOOST_ASIO_HAS_STD_ATOMIC)
+typedef boost::detail::atomic_count atomic_count;
+#endif // defined(BOOST_ASIO_HAS_STD_ATOMIC)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
index 0199643..416712d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
@@ -35,6 +35,12 @@ public:
   {
   }
 
+  binder1(Handler& handler, const Arg1& arg1)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      arg1_(arg1)
+  {
+  }
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_));
@@ -67,6 +73,14 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
 }
 
 template <typename Function, typename Handler, typename Arg1>
+inline void asio_handler_invoke(Function& function,
+    binder1<Handler, Arg1>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+}
+
+template <typename Function, typename Handler, typename Arg1>
 inline void asio_handler_invoke(const Function& function,
     binder1<Handler, Arg1>* this_handler)
 {
@@ -75,7 +89,7 @@ inline void asio_handler_invoke(const Function& function,
 }
 
 template <typename Handler, typename Arg1>
-inline binder1<Handler, Arg1> bind_handler(const Handler& handler,
+inline binder1<Handler, Arg1> bind_handler(Handler handler,
     const Arg1& arg1)
 {
   return binder1<Handler, Arg1>(handler, arg1);
@@ -92,6 +106,13 @@ public:
   {
   }
 
+  binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      arg1_(arg1),
+      arg2_(arg2)
+  {
+  }
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
@@ -126,6 +147,14 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
 }
 
 template <typename Function, typename Handler, typename Arg1, typename Arg2>
+inline void asio_handler_invoke(Function& function,
+    binder2<Handler, Arg1, Arg2>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+}
+
+template <typename Function, typename Handler, typename Arg1, typename Arg2>
 inline void asio_handler_invoke(const Function& function,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
@@ -134,7 +163,7 @@ inline void asio_handler_invoke(const Function& function,
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
-inline binder2<Handler, Arg1, Arg2> bind_handler(const Handler& handler,
+inline binder2<Handler, Arg1, Arg2> bind_handler(Handler handler,
     const Arg1& arg1, const Arg2& arg2)
 {
   return binder2<Handler, Arg1, Arg2>(handler, arg1, arg2);
@@ -153,6 +182,15 @@ public:
   {
   }
 
+  binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2,
+      const Arg3& arg3)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      arg1_(arg1),
+      arg2_(arg2),
+      arg3_(arg3)
+  {
+  }
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
@@ -190,6 +228,15 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
 
 template <typename Function, typename Handler, typename Arg1, typename Arg2,
     typename Arg3>
+inline void asio_handler_invoke(Function& function,
+    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+}
+
+template <typename Function, typename Handler, typename Arg1, typename Arg2,
+    typename Arg3>
 inline void asio_handler_invoke(const Function& function,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
@@ -198,7 +245,7 @@ inline void asio_handler_invoke(const Function& function,
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline binder3<Handler, Arg1, Arg2, Arg3> bind_handler(const Handler& handler,
+inline binder3<Handler, Arg1, Arg2, Arg3> bind_handler(Handler handler,
     const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
 {
   return binder3<Handler, Arg1, Arg2, Arg3>(handler, arg1, arg2, arg3);
@@ -219,6 +266,16 @@ public:
   {
   }
 
+  binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2,
+      const Arg3& arg3, const Arg4& arg4)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      arg1_(arg1),
+      arg2_(arg2),
+      arg3_(arg3),
+      arg4_(arg4)
+  {
+  }
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
@@ -260,6 +317,15 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
 
 template <typename Function, typename Handler, typename Arg1, typename Arg2,
     typename Arg3, typename Arg4>
+inline void asio_handler_invoke(Function& function,
+    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+}
+
+template <typename Function, typename Handler, typename Arg1, typename Arg2,
+    typename Arg3, typename Arg4>
 inline void asio_handler_invoke(const Function& function,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
@@ -270,7 +336,7 @@ inline void asio_handler_invoke(const Function& function,
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4>
 inline binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
-    const Handler& handler, const Arg1& arg1, const Arg2& arg2,
+    Handler handler, const Arg1& arg1, const Arg2& arg2,
     const Arg3& arg3, const Arg4& arg4)
 {
   return binder4<Handler, Arg1, Arg2, Arg3, Arg4>(handler, arg1, arg2, arg3,
@@ -293,6 +359,17 @@ public:
   {
   }
 
+  binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
+      const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      arg1_(arg1),
+      arg2_(arg2),
+      arg3_(arg3),
+      arg4_(arg4),
+      arg5_(arg5)
+  {
+  }
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
@@ -336,6 +413,15 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
 
 template <typename Function, typename Handler, typename Arg1, typename Arg2,
     typename Arg3, typename Arg4, typename Arg5>
+inline void asio_handler_invoke(Function& function,
+    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+}
+
+template <typename Function, typename Handler, typename Arg1, typename Arg2,
+    typename Arg3, typename Arg4, typename Arg5>
 inline void asio_handler_invoke(const Function& function,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
@@ -346,7 +432,7 @@ inline void asio_handler_invoke(const Function& function,
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4, typename Arg5>
 inline binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
-    const Handler& handler, const Arg1& arg1, const Arg2& arg2,
+    Handler handler, const Arg1& arg1, const Arg2& arg2,
     const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
 {
   return binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>(handler, arg1, arg2,
diff --git a/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
index fdda23f..061daf1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
@@ -81,11 +81,11 @@ class buffer_sequence_adapter
   : buffer_sequence_adapter_base
 {
 public:
-  explicit buffer_sequence_adapter(const Buffers& buffers)
+  explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
     : count_(0), total_buffer_size_(0)
   {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
+    typename Buffers::const_iterator iter = buffer_sequence.begin();
+    typename Buffers::const_iterator end = buffer_sequence.end();
     for (; iter != end && count_ < max_buffers; ++iter, ++count_)
     {
       Buffer buffer(*iter);
@@ -109,10 +109,10 @@ public:
     return total_buffer_size_ == 0;
   }
 
-  static bool all_empty(const Buffers& buffers)
+  static bool all_empty(const Buffers& buffer_sequence)
   {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
+    typename Buffers::const_iterator iter = buffer_sequence.begin();
+    typename Buffers::const_iterator end = buffer_sequence.end();
     std::size_t i = 0;
     for (; iter != end && i < max_buffers; ++iter, ++i)
       if (boost::asio::buffer_size(Buffer(*iter)) > 0)
@@ -120,10 +120,10 @@ public:
     return true;
   }
 
-  static void validate(const Buffers& buffers)
+  static void validate(const Buffers& buffer_sequence)
   {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
+    typename Buffers::const_iterator iter = buffer_sequence.begin();
+    typename Buffers::const_iterator end = buffer_sequence.end();
     for (; iter != end; ++iter)
     {
       Buffer buffer(*iter);
@@ -131,10 +131,10 @@ public:
     }
   }
 
-  static Buffer first(const Buffers& buffers)
+  static Buffer first(const Buffers& buffer_sequence)
   {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
+    typename Buffers::const_iterator iter = buffer_sequence.begin();
+    typename Buffers::const_iterator end = buffer_sequence.end();
     for (; iter != end; ++iter)
     {
       Buffer buffer(*iter);
@@ -159,10 +159,10 @@ class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
 {
 public:
   explicit buffer_sequence_adapter(
-      const boost::asio::mutable_buffers_1& buffers)
+      const boost::asio::mutable_buffers_1& buffer_sequence)
   {
-    init_native_buffer(buffer_, Buffer(buffers));
-    total_buffer_size_ = boost::asio::buffer_size(buffers);
+    init_native_buffer(buffer_, Buffer(buffer_sequence));
+    total_buffer_size_ = boost::asio::buffer_size(buffer_sequence);
   }
 
   native_buffer_type* buffers()
@@ -180,19 +180,19 @@ public:
     return total_buffer_size_ == 0;
   }
 
-  static bool all_empty(const boost::asio::mutable_buffers_1& buffers)
+  static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
   {
-    return boost::asio::buffer_size(buffers) == 0;
+    return boost::asio::buffer_size(buffer_sequence) == 0;
   }
 
-  static void validate(const boost::asio::mutable_buffers_1& buffers)
+  static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
   {
-    boost::asio::buffer_cast<const void*>(buffers);
+    boost::asio::buffer_cast<const void*>(buffer_sequence);
   }
 
-  static Buffer first(const boost::asio::mutable_buffers_1& buffers)
+  static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
   {
-    return Buffer(buffers);
+    return Buffer(buffer_sequence);
   }
 
 private:
@@ -206,10 +206,10 @@ class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
 {
 public:
   explicit buffer_sequence_adapter(
-      const boost::asio::const_buffers_1& buffers)
+      const boost::asio::const_buffers_1& buffer_sequence)
   {
-    init_native_buffer(buffer_, Buffer(buffers));
-    total_buffer_size_ = boost::asio::buffer_size(buffers);
+    init_native_buffer(buffer_, Buffer(buffer_sequence));
+    total_buffer_size_ = boost::asio::buffer_size(buffer_sequence);
   }
 
   native_buffer_type* buffers()
@@ -227,19 +227,19 @@ public:
     return total_buffer_size_ == 0;
   }
 
-  static bool all_empty(const boost::asio::const_buffers_1& buffers)
+  static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
   {
-    return boost::asio::buffer_size(buffers) == 0;
+    return boost::asio::buffer_size(buffer_sequence) == 0;
   }
 
-  static void validate(const boost::asio::const_buffers_1& buffers)
+  static void validate(const boost::asio::const_buffers_1& buffer_sequence)
   {
-    boost::asio::buffer_cast<const void*>(buffers);
+    boost::asio::buffer_cast<const void*>(buffer_sequence);
   }
 
-  static Buffer first(const boost::asio::const_buffers_1& buffers)
+  static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
   {
-    return Buffer(buffers);
+    return Buffer(buffer_sequence);
   }
 
 private:
diff --git a/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp b/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
index 86763b5..dd2e93a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
@@ -16,7 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <cassert>
+#include <boost/asio/buffer.hpp>
+#include <boost/assert.hpp>
 #include <cstddef>
 #include <cstring>
 #include <vector>
@@ -37,10 +38,10 @@ public:
   typedef std::size_t size_type;
 
   // Constructor.
-  explicit buffered_stream_storage(std::size_t capacity)
+  explicit buffered_stream_storage(std::size_t buffer_capacity)
     : begin_offset_(0),
       end_offset_(0),
-      buffer_(capacity)
+      buffer_(buffer_capacity)
   {
   }
 
@@ -52,15 +53,15 @@ public:
   }
 
   // Return a pointer to the beginning of the unread data.
-  byte_type* data()
+  mutable_buffer data()
   {
-    return &buffer_[0] + begin_offset_;
+    return boost::asio::buffer(buffer_) + begin_offset_;
   }
 
   // Return a pointer to the beginning of the unread data.
-  const byte_type* data() const
+  const_buffer data() const
   {
-    return &buffer_[0] + begin_offset_;
+    return boost::asio::buffer(buffer_) + begin_offset_;
   }
 
   // Is there no unread data in the buffer.
@@ -78,7 +79,7 @@ public:
   // Resize the buffer to the specified length.
   void resize(size_type length)
   {
-    assert(length <= capacity());
+    BOOST_ASSERT(length <= capacity());
     if (begin_offset_ + length <= capacity())
     {
       end_offset_ = begin_offset_ + length;
@@ -101,7 +102,7 @@ public:
   // Consume multiple bytes from the beginning of the buffer.
   void consume(size_type count)
   {
-    assert(begin_offset_ + count <= end_offset_);
+    BOOST_ASSERT(begin_offset_ + count <= end_offset_);
     begin_offset_ += count;
     if (empty())
       clear();
diff --git a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
index 3b023d1..144ad7f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
@@ -33,9 +33,9 @@ class completion_handler : public operation
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(completion_handler);
 
-  completion_handler(Handler h)
+  completion_handler(Handler& h)
     : operation(&completion_handler::do_complete),
-      handler_(h)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
   {
   }
 
@@ -46,13 +46,15 @@ public:
     completion_handler* h(static_cast<completion_handler*>(base));
     ptr p = { boost::addressof(h->handler_), h, h };
 
+    BOOST_ASIO_HANDLER_COMPLETION((h));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
-    Handler handler(h->handler_);
+    Handler handler(BOOST_ASIO_MOVE_CAST(Handler)(h->handler_));
     p.h = boost::addressof(handler);
     p.reset();
 
@@ -60,7 +62,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN(());
       boost_asio_handler_invoke_helpers::invoke(handler, handler);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/config.hpp b/3rdParty/Boost/src/boost/asio/detail/config.hpp
index 45c2415..61430b6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/config.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/config.hpp
@@ -46,6 +46,114 @@
 # define BOOST_ASIO_DECL
 #endif // !defined(BOOST_ASIO_DECL)
 
+// Support move construction and assignment on compilers known to allow it.
+#if !defined(BOOST_ASIO_DISABLE_MOVE)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define BOOST_ASIO_HAS_MOVE
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+#endif // !defined(BOOST_ASIO_DISABLE_MOVE)
+
+// If BOOST_ASIO_MOVE_CAST isn't defined, and move support is available, define
+// BOOST_ASIO_MOVE_ARG and BOOST_ASIO_MOVE_CAST to take advantage of rvalue
+// references and perfect forwarding.
+#if defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST)
+# define BOOST_ASIO_MOVE_ARG(type) type&&
+# define BOOST_ASIO_MOVE_CAST(type) static_cast<type&&>
+#endif // defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST)
+
+// If BOOST_ASIO_MOVE_CAST still isn't defined, default to a C++03-compatible
+// implementation. Note that older g++ and MSVC versions don't like it when you
+// pass a non-member function through a const reference, so for most compilers
+// we'll play it safe and stick with the old approach of passing the handler by
+// value.
+#if !defined(BOOST_ASIO_MOVE_CAST)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
+#   define BOOST_ASIO_MOVE_ARG(type) const type&
+#  else // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
+#   define BOOST_ASIO_MOVE_ARG(type) type
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
+# elif defined(BOOST_MSVC)
+#  if (_MSC_VER >= 1400)
+#   define BOOST_ASIO_MOVE_ARG(type) const type&
+#  else // (_MSC_VER >= 1400)
+#   define BOOST_ASIO_MOVE_ARG(type) type
+#  endif // (_MSC_VER >= 1400)
+# else
+#  define BOOST_ASIO_MOVE_ARG(type) type
+# endif
+# define BOOST_ASIO_MOVE_CAST(type) static_cast<const type&>
+#endif // !defined_BOOST_ASIO_MOVE_CAST
+
+// Support variadic templates on compilers known to allow it.
+#if !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define BOOST_ASIO_HAS_VARIADIC_TEMPLATES
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+#endif // !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES)
+
+// Standard library support for system errors.
+#if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define BOOST_ASIO_HAS_STD_SYSTEM_ERROR
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+#endif // !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
+
+// Standard library support for arrays.
+#if !defined(BOOST_ASIO_DISABLE_STD_ARRAY)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define BOOST_ASIO_HAS_STD_ARRAY
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+# if defined(BOOST_MSVC)
+#  if (_MSC_VER >= 1600)
+#   define BOOST_ASIO_HAS_STD_ARRAY
+#  endif // (_MSC_VER >= 1600)
+# endif // defined(BOOST_MSVC)
+#endif // !defined(BOOST_ASIO_DISABLE_STD_ARRAY)
+
+// Standard library support for shared_ptr and weak_ptr.
+#if !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define BOOST_ASIO_HAS_STD_SHARED_PTR
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+# if defined(BOOST_MSVC)
+#  if (_MSC_VER >= 1600)
+#   define BOOST_ASIO_HAS_STD_SHARED_PTR
+#  endif // (_MSC_VER >= 1600)
+# endif // defined(BOOST_MSVC)
+#endif // !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR)
+
+// Standard library support for atomic operations.
+#if !defined(BOOST_ASIO_DISABLE_STD_ATOMIC)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define BOOST_ASIO_HAS_STD_ATOMIC
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+#endif // !defined(BOOST_ASIO_DISABLE_STD_ATOMIC)
+
 // Windows: target OS version.
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 # if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
@@ -202,4 +310,18 @@
 # endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 #endif // !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS)
 
+// Can use sigaction() instead of signal().
+#if !defined(BOOST_ASIO_DISABLE_SIGACTION)
+# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#  define BOOST_ASIO_HAS_SIGACTION 1
+# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_DISABLE_SIGACTION)
+
+// Can use signal().
+#if !defined(BOOST_ASIO_DISABLE_SIGNAL)
+# if !defined(UNDER_CE)
+#  define BOOST_ASIO_HAS_SIGNAL 1
+# endif // !defined(UNDER_CE)
+#endif // !defined(BOOST_ASIO_DISABLE_SIGNAL)
+
 #endif // BOOST_ASIO_DETAIL_CONFIG_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp b/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
index 82e0d43..839a98e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
@@ -100,12 +100,35 @@ public:
       ec = boost::system::error_code();
       return 0;
     }
+
+    BOOST_ASIO_HANDLER_OPERATION(("deadline_timer", &impl, "cancel"));
+
     std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
     impl.might_have_pending_waits = false;
     ec = boost::system::error_code();
     return count;
   }
 
+  // Cancels one asynchronous wait operation associated with the timer.
+  std::size_t cancel_one(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    if (!impl.might_have_pending_waits)
+    {
+      ec = boost::system::error_code();
+      return 0;
+    }
+
+    BOOST_ASIO_HANDLER_OPERATION(("deadline_timer", &impl, "cancel_one"));
+
+    std::size_t count = scheduler_.cancel_timer(
+        timer_queue_, impl.timer_data, 1);
+    if (count == 0)
+      impl.might_have_pending_waits = false;
+    ec = boost::system::error_code();
+    return count;
+  }
+
   // Get the expiry time for the timer as an absolute time.
   time_type expires_at(const implementation_type& impl) const
   {
@@ -140,18 +163,17 @@ public:
   void wait(implementation_type& impl, boost::system::error_code& ec)
   {
     time_type now = Time_Traits::now();
-    while (Time_Traits::less_than(now, impl.expiry))
+    ec = boost::system::error_code();
+    while (Time_Traits::less_than(now, impl.expiry) && !ec)
     {
       boost::posix_time::time_duration timeout =
         Time_Traits::to_posix_duration(Time_Traits::subtract(impl.expiry, now));
       ::timeval tv;
       tv.tv_sec = timeout.total_seconds();
       tv.tv_usec = timeout.total_microseconds() % 1000000;
-      boost::system::error_code ec;
       socket_ops::select(0, 0, 0, 0, &tv, ec);
       now = Time_Traits::now();
     }
-    ec = boost::system::error_code();
   }
 
   // Start an asynchronous wait on the timer.
@@ -167,6 +189,8 @@ public:
 
     impl.might_have_pending_waits = true;
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "deadline_timer", &impl, "async_wait"));
+
     scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
     p.v = p.p = 0;
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
index f92a7b4..1eccf3a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
@@ -40,7 +40,10 @@ enum
   internal_non_blocking = 2,
 
   // Helper "state" used to determine whether the descriptor is non-blocking.
-  non_blocking = user_set_non_blocking | internal_non_blocking
+  non_blocking = user_set_non_blocking | internal_non_blocking,
+
+  // The descriptor may have been dup()-ed.
+  possible_dup = 4
 };
 
 typedef unsigned char state_type;
@@ -60,8 +63,11 @@ BOOST_ASIO_DECL int open(const char* path, int flags,
 BOOST_ASIO_DECL int close(int d, state_type& state,
     boost::system::error_code& ec);
 
+BOOST_ASIO_DECL bool set_user_non_blocking(int d,
+    state_type& state, bool value, boost::system::error_code& ec);
+
 BOOST_ASIO_DECL bool set_internal_non_blocking(int d,
-    state_type& state, boost::system::error_code& ec);
+    state_type& state, bool value, boost::system::error_code& ec);
 
 typedef iovec buf;
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
index 884f8f6..94861e0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
@@ -68,10 +68,10 @@ public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_read_op);
 
   descriptor_read_op(int descriptor,
-      const MutableBufferSequence& buffers, Handler handler)
+      const MutableBufferSequence& buffers, Handler& handler)
     : descriptor_read_op_base<MutableBufferSequence>(
         descriptor, buffers, &descriptor_read_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -82,6 +82,8 @@ public:
     descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -97,7 +99,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
index 805eb0b..60efb18 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
@@ -68,10 +68,10 @@ public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_write_op);
 
   descriptor_write_op(int descriptor,
-      const ConstBufferSequence& buffers, Handler handler)
+      const ConstBufferSequence& buffers, Handler& handler)
     : descriptor_write_op_base<ConstBufferSequence>(
         descriptor, buffers, &descriptor_write_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -82,6 +82,8 @@ public:
     descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -97,7 +99,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
index 79c1cbb..66558c4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
@@ -19,6 +19,7 @@
 
 #if defined(BOOST_ASIO_HAS_DEV_POLL)
 
+#include <boost/limits.hpp>
 #include <cstddef>
 #include <vector>
 #include <sys/devpoll.h>
@@ -63,6 +64,10 @@ public:
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
+  // Recreate internal descriptors following a fork.
+  BOOST_ASIO_DECL void fork_service(
+      boost::asio::io_service::fork_event fork_ev);
+
   // Initialise the task.
   BOOST_ASIO_DECL void init_task();
 
@@ -70,6 +75,17 @@ public:
   // code on failure.
   BOOST_ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
 
+  // Register a descriptor with an associated single operation. Returns 0 on
+  // success, system error code on failure.
+  BOOST_ASIO_DECL int register_internal_descriptor(
+      int op_type, socket_type descriptor,
+      per_descriptor_data& descriptor_data, reactor_op* op);
+
+  // Move descriptor registration from one descriptor_data object to another.
+  BOOST_ASIO_DECL void move_descriptor(socket_type descriptor,
+      per_descriptor_data& target_descriptor_data,
+      per_descriptor_data& source_descriptor_data);
+
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op)
   {
@@ -88,7 +104,12 @@ public:
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void close_descriptor(
+  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
+      per_descriptor_data&, bool closing);
+
+  // Cancel any operations that are running against the descriptor and remove
+  // its registration from the reactor.
+  BOOST_ASIO_DECL void deregister_internal_descriptor(
       socket_type descriptor, per_descriptor_data&);
 
   // Add a new timer queue to the reactor.
@@ -110,7 +131,8 @@ public:
   // number of operations that have been posted or dispatched.
   template <typename Time_Traits>
   std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer);
+      typename timer_queue<Time_Traits>::per_timer_data& timer,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
   // Run /dev/poll once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
@@ -140,6 +162,10 @@ private:
   BOOST_ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
       const boost::system::error_code& ec);
 
+  // Helper class used to reregister descriptors after a fork.
+  class fork_helper;
+  friend class fork_helper;
+
   // Add a pending event entry for the given descriptor.
   BOOST_ASIO_DECL ::pollfd& add_pending_event_change(int descriptor);
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
index 1889017..0c3dcec 100644
--- a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
@@ -19,6 +19,7 @@
 
 #if defined(BOOST_ASIO_HAS_EPOLL)
 
+#include <boost/limits.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/epoll_reactor_fwd.hpp>
 #include <boost/asio/detail/mutex.hpp>
@@ -51,6 +52,7 @@ public:
     friend class epoll_reactor;
     friend class object_pool_access;
     mutex mutex_;
+    int descriptor_;
     op_queue<reactor_op> op_queue_[max_ops];
     bool shutdown_;
     descriptor_state* next_;
@@ -69,6 +71,10 @@ public:
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
+  // Recreate internal descriptors following a fork.
+  BOOST_ASIO_DECL void fork_service(
+      boost::asio::io_service::fork_event fork_ev);
+
   // Initialise the task.
   BOOST_ASIO_DECL void init_task();
 
@@ -77,6 +83,17 @@ public:
   BOOST_ASIO_DECL int register_descriptor(socket_type descriptor,
       per_descriptor_data& descriptor_data);
 
+  // Register a descriptor with an associated single operation. Returns 0 on
+  // success, system error code on failure.
+  BOOST_ASIO_DECL int register_internal_descriptor(
+      int op_type, socket_type descriptor,
+      per_descriptor_data& descriptor_data, reactor_op* op);
+
+  // Move descriptor registration from one descriptor_data object to another.
+  BOOST_ASIO_DECL void move_descriptor(socket_type descriptor,
+      per_descriptor_data& target_descriptor_data,
+      per_descriptor_data& source_descriptor_data);
+
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op)
   {
@@ -86,8 +103,8 @@ public:
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
   BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data,
-      reactor_op* op, bool allow_speculative);
+      per_descriptor_data& descriptor_data, reactor_op* op,
+      bool allow_speculative);
 
   // Cancel all operations associated with the given descriptor. The
   // handlers associated with the descriptor will be invoked with the
@@ -97,8 +114,12 @@ public:
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void close_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
+  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
+      per_descriptor_data& descriptor_data, bool closing);
+
+  // Remote the descriptor's registration from the reactor.
+  BOOST_ASIO_DECL void deregister_internal_descriptor(
+      socket_type descriptor, per_descriptor_data& descriptor_data);
 
   // Add a new timer queue to the reactor.
   template <typename Time_Traits>
@@ -119,7 +140,8 @@ public:
   // number of operations that have been posted or dispatched.
   template <typename Time_Traits>
   std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer);
+      typename timer_queue<Time_Traits>::per_timer_data& timer,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
   // Run epoll once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
@@ -135,6 +157,9 @@ private:
   // cannot be created.
   BOOST_ASIO_DECL static int do_epoll_create();
 
+  // Create the timerfd file descriptor. Does not throw.
+  BOOST_ASIO_DECL static int do_timerfd_create();
+
   // Helper function to add a new timer queue.
   BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
index 954fe79..22926e8 100644
--- a/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
@@ -35,6 +35,9 @@ public:
   // Destructor.
   BOOST_ASIO_DECL ~eventfd_select_interrupter();
 
+  // Recreate the interrupter's descriptors. Used after a fork.
+  BOOST_ASIO_DECL void recreate();
+
   // Interrupt the select call.
   BOOST_ASIO_DECL void interrupt();
 
@@ -48,6 +51,12 @@ public:
   }
 
 private:
+  // Open the descriptors. Throws on error.
+  BOOST_ASIO_DECL void open_descriptors();
+
+  // Close the descriptors.
+  BOOST_ASIO_DECL void close_descriptors();
+
   // The read end of a connection used to interrupt the select call. This file
   // descriptor is passed to select such that when it is time to stop, a single
   // 64bit value will be written on the other end of the connection and this
diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp
index 58cdfb4..4081f7f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp
@@ -57,9 +57,14 @@ private:
     || defined(__ARM_ARCH_6Z__) \
     || defined(__ARM_ARCH_6ZK__) \
     || defined(__ARM_ARCH_6T2__)
+# if defined(__thumb__)
+    // This is just a placeholder and almost certainly not sufficient.
+    __asm__ __volatile__ ("" : : : "memory");
+# else // defined(__thumb__)
     int a = 0, b = 0;
     __asm__ __volatile__ ("swp %0, %1, [%2]"
         : "=&r"(a) : "r"(1), "r"(&b) : "memory", "cc");
+# endif // defined(__thumb__)
 #else
     // ARMv7 and later.
     __asm__ __volatile__ ("dmb" : : : "memory");
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
index fc3ec33..609fb4b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
@@ -35,7 +35,7 @@ inline void* allocate(std::size_t s, Handler& h)
   || BOOST_WORKAROUND(__GNUC__, < 3)
   return ::operator new(s);
 #else
-  using namespace boost::asio;
+  using boost::asio::asio_handler_allocate;
   return asio_handler_allocate(s, boost::addressof(h));
 #endif
 }
@@ -47,7 +47,7 @@ inline void deallocate(void* p, std::size_t s, Handler& h)
   || BOOST_WORKAROUND(__GNUC__, < 3)
   ::operator delete(p);
 #else
-  using namespace boost::asio;
+  using boost::asio::asio_handler_deallocate;
   asio_handler_deallocate(p, s, boost::addressof(h));
 #endif
 }
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
index 3b44997..7c4320d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
@@ -28,6 +28,19 @@
 namespace boost_asio_handler_invoke_helpers {
 
 template <typename Function, typename Context>
+inline void invoke(Function& function, Context& context)
+{
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
+  || BOOST_WORKAROUND(__GNUC__, < 3)
+  Function tmp(function);
+  tmp();
+#else
+  using boost::asio::asio_handler_invoke;
+  asio_handler_invoke(function, boost::addressof(context));
+#endif
+}
+
+template <typename Function, typename Context>
 inline void invoke(const Function& function, Context& context)
 {
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
@@ -35,7 +48,7 @@ inline void invoke(const Function& function, Context& context)
   Function tmp(function);
   tmp();
 #else
-  using namespace boost::asio;
+  using boost::asio::asio_handler_invoke;
   asio_handler_invoke(function, boost::addressof(context));
 #endif
 }
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp
new file mode 100644
index 0000000..7f3dc84
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp
@@ -0,0 +1,161 @@
+//
+// detail/handler_tracking.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_DETAIL_HANDLER_TRACKING_HPP
+#define BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+# include <boost/cstdint.hpp>
+# include <boost/system/error_code.hpp>
+# include <boost/asio/detail/static_mutex.hpp>
+# include <boost/asio/detail/tss_ptr.hpp>
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+
+class handler_tracking
+{
+public:
+  class completion;
+
+  // Base class for objects containing tracked handlers.
+  class tracked_handler
+  {
+  private:
+    // Only the handler_tracking class will have access to the id.
+    friend class handler_tracking;
+    friend class completion;
+    boost::uint64_t id_;
+
+  protected:
+    // Constructor initialises with no id.
+    tracked_handler() : id_(0) {}
+
+    // Prevent deletion through this type.
+    ~tracked_handler() {}
+  };
+
+  // Initialise the tracking system.
+  BOOST_ASIO_DECL static void init();
+
+  // Record the creation of a tracked handler.
+  BOOST_ASIO_DECL static void creation(tracked_handler* h,
+      const char* object_type, void* object, const char* op_name);
+
+  class completion
+  {
+  public:
+    // Constructor records that handler is to be invoked with no arguments.
+    BOOST_ASIO_DECL explicit completion(tracked_handler* h);
+
+    // Destructor records only when an exception is thrown from the handler, or
+    // if the memory is being freed without the handler having been invoked.
+    BOOST_ASIO_DECL ~completion();
+
+    // Records that handler is to be invoked with no arguments.
+    BOOST_ASIO_DECL void invocation_begin();
+
+    // Records that handler is to be invoked with one arguments.
+    BOOST_ASIO_DECL void invocation_begin(const boost::system::error_code& ec);
+
+    // Constructor records that handler is to be invoked with two arguments.
+    BOOST_ASIO_DECL void invocation_begin(
+        const boost::system::error_code& ec, std::size_t bytes_transferred);
+
+    // Constructor records that handler is to be invoked with two arguments.
+    BOOST_ASIO_DECL void invocation_begin(
+        const boost::system::error_code& ec, int signal_number);
+
+    // Constructor records that handler is to be invoked with two arguments.
+    BOOST_ASIO_DECL void invocation_begin(
+        const boost::system::error_code& ec, const char* arg);
+
+    // Record that handler invocation has ended.
+    BOOST_ASIO_DECL void invocation_end();
+
+  private:
+    friend class handler_tracking;
+    boost::uint64_t id_;
+    bool invoked_;
+    completion* next_;
+  };
+
+  // Record an operation that affects pending handlers.
+  BOOST_ASIO_DECL static void operation(const char* object_type,
+      void* object, const char* op_name);
+
+  // Write a line of output.
+  BOOST_ASIO_DECL static void write_line(const char* format, ...);
+
+private:
+  struct tracking_state;
+  BOOST_ASIO_DECL static tracking_state* get_state();
+};
+
+# define BOOST_ASIO_INHERIT_TRACKED_HANDLER \
+  : public boost::asio::detail::handler_tracking::tracked_handler
+
+# define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER \
+  , public boost::asio::detail::handler_tracking::tracked_handler
+
+# define BOOST_ASIO_HANDLER_TRACKING_INIT \
+  boost::asio::detail::handler_tracking::init()
+
+# define BOOST_ASIO_HANDLER_CREATION(args) \
+  boost::asio::detail::handler_tracking::creation args
+
+# define BOOST_ASIO_HANDLER_COMPLETION(args) \
+  boost::asio::detail::handler_tracking::completion tracked_completion args
+
+# define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) \
+  tracked_completion.invocation_begin args
+
+# define BOOST_ASIO_HANDLER_INVOCATION_END \
+  tracked_completion.invocation_end()
+
+# define BOOST_ASIO_HANDLER_OPERATION(args) \
+  boost::asio::detail::handler_tracking::operation args
+
+#else // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+
+# define BOOST_ASIO_INHERIT_TRACKED_HANDLER
+# define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
+# define BOOST_ASIO_HANDLER_TRACKING_INIT (void)0
+# define BOOST_ASIO_HANDLER_CREATION(args) (void)0
+# define BOOST_ASIO_HANDLER_COMPLETION(args) (void)0
+# define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0
+# define BOOST_ASIO_HANDLER_INVOCATION_END (void)0
+# define BOOST_ASIO_HANDLER_OPERATION(args) (void)0
+
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/handler_tracking.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp
new file mode 100644
index 0000000..342af1e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp
@@ -0,0 +1,362 @@
+//
+// detail/handler_type_requirements.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_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
+#define BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+// Older versions of gcc have difficulty compiling the sizeof expressions where
+// we test the handler type requirements. We'll disable checking of handler type
+// requirements for those compilers, but otherwise enable it by default.
+#if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
+# if !defined(__GNUC__) || (__GNUC__ >= 4)
+#  define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
+# endif // !defined(__GNUC__) || (__GNUC__ >= 4)
+#endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
+
+// With C++0x we can use a combination of enhanced SFINAE and static_assert to
+// generate better template error messages. As this technique is not yet widely
+// portable, we'll only enable it for tested compilers.
+#if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+# if defined(BOOST_MSVC)
+#  if (_MSC_VER >= 1600)
+#   define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
+#  endif // (_MSC_VER >= 1600)
+# endif // defined(BOOST_MSVC)
+#endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
+
+# if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
+
+template <typename Handler>
+auto zero_arg_handler_test(Handler h, void*)
+  -> decltype(
+    sizeof(Handler(static_cast<const Handler&>(h))),
+    ((h)()),
+    char(0));
+
+template <typename Handler>
+char (&zero_arg_handler_test(Handler, ...))[2];
+
+template <typename Handler, typename Arg1>
+auto one_arg_handler_test(Handler h, Arg1* a1)
+  -> decltype(
+    sizeof(Handler(static_cast<const Handler&>(h))),
+    ((h)(*a1)),
+    char(0));
+
+template <typename Handler>
+char (&one_arg_handler_test(Handler h, ...))[2];
+
+template <typename Handler, typename Arg1, typename Arg2>
+auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
+  -> decltype(
+    sizeof(Handler(static_cast<const Handler&>(h))),
+    ((h)(*a1, *a2)),
+    char(0));
+
+template <typename Handler>
+char (&two_arg_handler_test(Handler, ...))[2];
+
+#  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \
+     static_assert(expr, msg);
+
+# else // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
+
+#  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg)
+
+# endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
+
+template <typename T> T& lvref();
+template <typename T> T& lvref(T);
+template <typename T> const T& clvref(T);
+template <typename T> char argbyv(T);
+
+template <int>
+struct handler_type_requirements
+{
+};
+
+#define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::zero_arg_handler_test( \
+          handler, 0)) == 1, \
+      "CompletionHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)(), \
+        char(0))>
+
+#define BOOST_ASIO_READ_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::two_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0), \
+          static_cast<const std::size_t*>(0))) == 1, \
+      "ReadHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>(), \
+          boost::asio::detail::lvref<const std::size_t>()), \
+        char(0))>
+
+#define BOOST_ASIO_WRITE_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::two_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0), \
+          static_cast<const std::size_t*>(0))) == 1, \
+      "WriteHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>(), \
+          boost::asio::detail::lvref<const std::size_t>()), \
+        char(0))>
+
+#define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::one_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0))) == 1, \
+      "AcceptHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))>
+
+#define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::one_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0))) == 1, \
+      "ConnectHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))>
+
+#define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
+    handler_type, handler, iter_type) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::two_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0), \
+          static_cast<const iter_type*>(0))) == 1, \
+      "ComposedConnectHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>(), \
+          boost::asio::detail::lvref<const iter_type>()), \
+        char(0))>
+
+#define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
+    handler_type, handler, iter_type) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::two_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0), \
+          static_cast<const iter_type*>(0))) == 1, \
+      "ResolveHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>(), \
+          boost::asio::detail::lvref<const iter_type>()), \
+        char(0))>
+
+#define BOOST_ASIO_WAIT_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::one_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0))) == 1, \
+      "WaitHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))>
+
+#define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::two_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0), \
+          static_cast<const int*>(0))) == 1, \
+      "SignalHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>(), \
+          boost::asio::detail::lvref<const int>()), \
+        char(0))>
+
+#define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::one_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0))) == 1, \
+      "HandshakeHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))>
+
+#define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::one_arg_handler_test( \
+          handler, \
+          static_cast<const boost::system::error_code*>(0))) == 1, \
+      "ShutdownHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref(handler))) + \
+      sizeof( \
+        boost::asio::detail::lvref(handler)( \
+          boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))>
+
+#else // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
+
+#define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_READ_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_WRITE_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
+    handler_type, handler, iter_type) \
+  typedef int
+
+#define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
+    handler_type, handler, iter_type) \
+  typedef int
+
+#define BOOST_ASIO_WAIT_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int
+
+#endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
index 4f4eed3..da1a9f4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
@@ -16,7 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <list>
 #include <utility>
 #include <boost/asio/detail/noncopyable.hpp>
@@ -117,9 +117,9 @@ public:
       iterator it = buckets_[bucket].first;
       if (it == values_.end())
         return values_.end();
-      iterator end = buckets_[bucket].last;
-      ++end;
-      while (it != end)
+      iterator end_it = buckets_[bucket].last;
+      ++end_it;
+      while (it != end_it)
       {
         if (it->first == k)
           return it;
@@ -138,9 +138,9 @@ public:
       const_iterator it = buckets_[bucket].first;
       if (it == values_.end())
         return it;
-      const_iterator end = buckets_[bucket].last;
-      ++end;
-      while (it != end)
+      const_iterator end_it = buckets_[bucket].last;
+      ++end_it;
+      while (it != end_it)
       {
         if (it->first == k)
           return it;
@@ -164,15 +164,15 @@ public:
       ++size_;
       return std::pair<iterator, bool>(buckets_[bucket].last, true);
     }
-    iterator end = buckets_[bucket].last;
-    ++end;
-    while (it != end)
+    iterator end_it = buckets_[bucket].last;
+    ++end_it;
+    while (it != end_it)
     {
       if (it->first == v.first)
         return std::pair<iterator, bool>(it, false);
       ++it;
     }
-    buckets_[bucket].last = values_insert(end, v);
+    buckets_[bucket].last = values_insert(end_it, v);
     ++size_;
     return std::pair<iterator, bool>(buckets_[bucket].last, true);
   }
@@ -180,7 +180,7 @@ public:
   // Erase an entry from the map.
   void erase(iterator it)
   {
-    assert(it != values_.end());
+    BOOST_ASSERT(it != values_.end());
 
     size_t bucket = calculate_hash_value(it->first) % num_buckets_;
     bool is_first = (it == buckets_[bucket].first);
@@ -212,9 +212,9 @@ public:
     size_ = 0;
 
     // Initialise all buckets to empty.
-    iterator end = values_.end();
+    iterator end_it = values_.end();
     for (size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end;
+      buckets_[i].first = buckets_[i].last = end_it;
   }
 
 private:
@@ -245,21 +245,21 @@ private:
       return;
     num_buckets_ = num_buckets;
 
-    iterator end = values_.end();
+    iterator end_iter = values_.end();
 
     // Update number of buckets and initialise all buckets to empty.
     bucket_type* tmp = new bucket_type[num_buckets_];
     delete[] buckets_;
     buckets_ = tmp;
     for (std::size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end;
+      buckets_[i].first = buckets_[i].last = end_iter;
 
     // Put all values back into the hash.
     iterator iter = values_.begin();
-    while (iter != end)
+    while (iter != end_iter)
     {
       std::size_t bucket = calculate_hash_value(iter->first) % num_buckets_;
-      if (buckets_[bucket].last == end)
+      if (buckets_[bucket].last == end_iter)
       {
         buckets_[bucket].first = buckets_[bucket].last = iter++;
       }
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
index 9a2bb3b..ca2222c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
@@ -43,8 +43,19 @@ int close(int d, state_type& state, boost::system::error_code& ec)
   int result = 0;
   if (d != -1)
   {
-    if (state & internal_non_blocking)
+    errno = 0;
+    result = error_wrapper(::close(d), ec);
+
+    if (result != 0
+        && (ec == boost::asio::error::would_block
+          || ec == boost::asio::error::try_again))
     {
+      // According to UNIX Network Programming Vol. 1, it is possible for
+      // close() to fail with EWOULDBLOCK under certain circumstances. What
+      // isn't clear is the state of the descriptor after this error. The one
+      // current OS where this behaviour is seen, Windows, says that the socket
+      // remains open. Therefore we'll put the descriptor back into blocking
+      // mode and have another attempt at closing it.
 #if defined(__SYMBIAN32__)
       int flags = ::fcntl(d, F_GETFL, 0);
       if (flags >= 0)
@@ -53,11 +64,11 @@ int close(int d, state_type& state, boost::system::error_code& ec)
       ioctl_arg_type arg = 0;
       ::ioctl(d, FIONBIO, &arg);
 #endif // defined(__SYMBIAN32__)
-      state &= ~internal_non_blocking;
-    }
+      state &= ~non_blocking;
 
-    errno = 0;
-    result = error_wrapper(::close(d), ec);
+      errno = 0;
+      result = error_wrapper(::close(d), ec);
+    }
   }
 
   if (result == 0)
@@ -65,8 +76,49 @@ int close(int d, state_type& state, boost::system::error_code& ec)
   return result;
 }
 
-bool set_internal_non_blocking(int d,
-    state_type& state, boost::system::error_code& ec)
+bool set_user_non_blocking(int d, state_type& state,
+    bool value, boost::system::error_code& ec)
+{
+  if (d == -1)
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return false;
+  }
+
+  errno = 0;
+#if defined(__SYMBIAN32__)
+  int result = error_wrapper(::fcntl(d, F_GETFL, 0), ec);
+  if (result >= 0)
+  {
+    errno = 0;
+    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+    result = error_wrapper(::fcntl(d, F_SETFL, flag), ec);
+  }
+#else // defined(__SYMBIAN32__)
+  ioctl_arg_type arg = (value ? 1 : 0);
+  int result = error_wrapper(::ioctl(d, FIONBIO, &arg), ec);
+#endif // defined(__SYMBIAN32__)
+
+  if (result >= 0)
+  {
+    ec = boost::system::error_code();
+    if (value)
+      state |= user_set_non_blocking;
+    else
+    {
+      // Clearing the user-set non-blocking mode always overrides any
+      // internally-set non-blocking flag. Any subsequent asynchronous
+      // operations will need to re-enable non-blocking I/O.
+      state &= ~(user_set_non_blocking | internal_non_blocking);
+    }
+    return true;
+  }
+
+  return false;
+}
+
+bool set_internal_non_blocking(int d, state_type& state,
+    bool value, boost::system::error_code& ec)
 {
   if (d == -1)
   {
@@ -74,23 +126,36 @@ bool set_internal_non_blocking(int d,
     return false;
   }
 
+  if (!value && (state & user_set_non_blocking))
+  {
+    // It does not make sense to clear the internal non-blocking flag if the
+    // user still wants non-blocking behaviour. Return an error and let the
+    // caller figure out whether to update the user-set non-blocking flag.
+    ec = boost::asio::error::invalid_argument;
+    return false;
+  }
+
   errno = 0;
 #if defined(__SYMBIAN32__)
   int result = error_wrapper(::fcntl(d, F_GETFL, 0), ec);
   if (result >= 0)
   {
     errno = 0;
-    result = error_wrapper(::fcntl(d, F_SETFL, result | O_NONBLOCK), ec);
+    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+    result = error_wrapper(::fcntl(d, F_SETFL, flag), ec);
   }
 #else // defined(__SYMBIAN32__)
-  ioctl_arg_type arg = 1;
+  ioctl_arg_type arg = (value ? 1 : 0);
   int result = error_wrapper(::ioctl(d, FIONBIO, &arg), ec);
 #endif // defined(__SYMBIAN32__)
 
   if (result >= 0)
   {
     ec = boost::system::error_code();
-    state |= internal_non_blocking;
+    if (value)
+      state |= internal_non_blocking;
+    else
+      state &= ~internal_non_blocking;
     return true;
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp
index a6b7078..54b313f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp
@@ -58,11 +58,12 @@ void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
 
 template <typename Time_Traits>
 std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp
index b9d5e61..a098256 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp
@@ -19,6 +19,7 @@
 
 #if defined(BOOST_ASIO_HAS_DEV_POLL)
 
+#include <boost/assert.hpp>
 #include <boost/asio/detail/dev_poll_reactor.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
@@ -38,7 +39,7 @@ dev_poll_reactor::dev_poll_reactor(boost::asio::io_service& io_service)
     shutdown_(false)
 {
   // Add the interrupter's descriptor to /dev/poll.
-  ::pollfd ev = { 0 };
+  ::pollfd ev = { 0, 0, 0 };
   ev.fd = interrupter_.read_descriptor();
   ev.events = POLLIN | POLLERR;
   ev.revents = 0;
@@ -63,8 +64,68 @@ void dev_poll_reactor::shutdown_service()
     op_queue_[i].get_all_operations(ops);
 
   timer_queues_.get_all_timers(ops);
+
+  io_service_.abandon_operations(ops);
 } 
 
+// Helper class to re-register all descriptors with /dev/poll.
+class dev_poll_reactor::fork_helper
+{
+public:
+  fork_helper(dev_poll_reactor* reactor, short events)
+    : reactor_(reactor), events_(events)
+  {
+  }
+
+  bool set(int descriptor)
+  {
+    ::pollfd& ev = reactor_->add_pending_event_change(descriptor);
+    ev.events = events_;
+    return true;
+  }
+
+private:
+  dev_poll_reactor* reactor_;
+  short events_;
+};
+
+void dev_poll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
+{
+  if (fork_ev == boost::asio::io_service::fork_child)
+  {
+    detail::mutex::scoped_lock lock(mutex_);
+
+    if (dev_poll_fd_ != -1)
+      ::close(dev_poll_fd_);
+    dev_poll_fd_ = -1;
+    dev_poll_fd_ = do_dev_poll_create();
+
+    interrupter_.recreate();
+
+    // Add the interrupter's descriptor to /dev/poll.
+    ::pollfd ev = { 0, 0, 0 };
+    ev.fd = interrupter_.read_descriptor();
+    ev.events = POLLIN | POLLERR;
+    ev.revents = 0;
+    ::write(dev_poll_fd_, &ev, sizeof(ev));
+
+    // Re-register all descriptors with /dev/poll. The changes will be written
+    // to the /dev/poll descriptor the next time the reactor is run.
+    op_queue<operation> ops;
+    fork_helper read_op_helper(this, POLLERR | POLLHUP | POLLIN);
+    op_queue_[read_op].get_descriptors(read_op_helper, ops);
+    fork_helper write_op_helper(this, POLLERR | POLLHUP | POLLOUT);
+    op_queue_[write_op].get_descriptors(write_op_helper, ops);
+    fork_helper except_op_helper(this, POLLERR | POLLHUP | POLLPRI);
+    op_queue_[except_op].get_descriptors(except_op_helper, ops);
+    interrupter_.interrupt();
+
+    // The ops op_queue will always be empty because the fork_helper's set()
+    // member function never returns false.
+    BOOST_ASSERT(ops.empty());
+  }
+}
+
 void dev_poll_reactor::init_task()
 {
   io_service_.init_task();
@@ -75,6 +136,32 @@ int dev_poll_reactor::register_descriptor(socket_type, per_descriptor_data&)
   return 0;
 }
 
+int dev_poll_reactor::register_internal_descriptor(int op_type,
+    socket_type descriptor, per_descriptor_data&, reactor_op* op)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+  op_queue_[op_type].enqueue_operation(descriptor, op);
+  ::pollfd& ev = add_pending_event_change(descriptor);
+  ev.events = POLLERR | POLLHUP;
+  switch (op_type)
+  {
+  case read_op: ev.events |= POLLIN; break;
+  case write_op: ev.events |= POLLOUT; break;
+  case except_op: ev.events |= POLLPRI; break;
+  default: break;
+  }
+  interrupter_.interrupt();
+
+  return 0;
+}
+
+void dev_poll_reactor::move_descriptor(socket_type,
+    dev_poll_reactor::per_descriptor_data&,
+    dev_poll_reactor::per_descriptor_data&)
+{
+}
+
 void dev_poll_reactor::start_op(int op_type, socket_type descriptor,
     dev_poll_reactor::per_descriptor_data&,
     reactor_op* op, bool allow_speculative)
@@ -129,8 +216,8 @@ void dev_poll_reactor::cancel_ops(socket_type descriptor,
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
-void dev_poll_reactor::close_descriptor(socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&)
+void dev_poll_reactor::deregister_descriptor(socket_type descriptor,
+    dev_poll_reactor::per_descriptor_data&, bool)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
@@ -143,6 +230,26 @@ void dev_poll_reactor::close_descriptor(socket_type descriptor,
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
+void dev_poll_reactor::deregister_internal_descriptor(
+    socket_type descriptor, dev_poll_reactor::per_descriptor_data&)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+  // Remove the descriptor from /dev/poll. Since this function is only called
+  // during a fork, we can apply the change immediately.
+  ::pollfd ev = { 0, 0, 0 };
+  ev.fd = descriptor;
+  ev.events = POLLREMOVE;
+  ev.revents = 0;
+  ::write(dev_poll_fd_, &ev, sizeof(ev));
+
+  // Destroy all operations associated with the descriptor.
+  op_queue<operation> ops;
+  boost::system::error_code ec;
+  for (int i = 0; i < max_ops; ++i)
+    op_queue_[i].cancel_operations(descriptor, ops, ec);
+}
+
 void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
@@ -179,8 +286,8 @@ void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
   lock.unlock();
 
   // Block on the /dev/poll descriptor.
-  ::pollfd events[128] = { { 0 } };
-  ::dvpoll dp = { 0 };
+  ::pollfd events[128] = { { 0, 0, 0 } };
+  ::dvpoll dp = { 0, 0, 0 };
   dp.dp_fds = events;
   dp.dp_nfds = 128;
   dp.dp_timeout = timeout;
@@ -228,7 +335,7 @@ void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
         // The poll operation can produce POLLHUP or POLLERR events when there
         // is no operation pending, so if we do not remove the descriptor we
         // can end up in a tight polling loop.
-        ::pollfd ev = { 0 };
+        ::pollfd ev = { 0, 0, 0 };
         ev.fd = descriptor;
         ev.events = POLLREMOVE;
         ev.revents = 0;
@@ -236,7 +343,7 @@ void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
       }
       else
       {
-        ::pollfd ev = { 0 };
+        ::pollfd ev = { 0, 0, 0 };
         ev.fd = descriptor;
         ev.events = POLLERR | POLLHUP;
         if (more_reads)
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
index 0339cfd..0e8ae40 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
@@ -56,11 +56,12 @@ void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
 
 template <typename Time_Traits>
 std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
 {
   mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
index 5afb891..3be2426 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
@@ -40,11 +40,7 @@ epoll_reactor::epoll_reactor(boost::asio::io_service& io_service)
     io_service_(use_service<io_service_impl>(io_service)),
     mutex_(),
     epoll_fd_(do_epoll_create()),
-#if defined(BOOST_ASIO_HAS_TIMERFD)
-    timer_fd_(timerfd_create(CLOCK_MONOTONIC, 0)),
-#else // defined(BOOST_ASIO_HAS_TIMERFD)
-    timer_fd_(-1),
-#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+    timer_fd_(do_timerfd_create()),
     interrupter_(),
     shutdown_(false)
 {
@@ -66,7 +62,8 @@ epoll_reactor::epoll_reactor(boost::asio::io_service& io_service)
 
 epoll_reactor::~epoll_reactor()
 {
-  close(epoll_fd_);
+  if (epoll_fd_ != -1)
+    close(epoll_fd_);
   if (timer_fd_ != -1)
     close(timer_fd_);
 }
@@ -88,6 +85,59 @@ void epoll_reactor::shutdown_service()
   }
 
   timer_queues_.get_all_timers(ops);
+
+  io_service_.abandon_operations(ops);
+}
+
+void epoll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
+{
+  if (fork_ev == boost::asio::io_service::fork_child)
+  {
+    if (epoll_fd_ != -1)
+      ::close(epoll_fd_);
+    epoll_fd_ = -1;
+    epoll_fd_ = do_epoll_create();
+
+    if (timer_fd_ != -1)
+      ::close(timer_fd_);
+    timer_fd_ = -1;
+    timer_fd_ = do_timerfd_create();
+
+    interrupter_.recreate();
+
+    // Add the interrupter's descriptor to epoll.
+    epoll_event ev = { 0, { 0 } };
+    ev.events = EPOLLIN | EPOLLERR | EPOLLET;
+    ev.data.ptr = &interrupter_;
+    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
+    interrupter_.interrupt();
+
+    // Add the timer descriptor to epoll.
+    if (timer_fd_ != -1)
+    {
+      ev.events = EPOLLIN | EPOLLERR;
+      ev.data.ptr = &timer_fd_;
+      epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
+    }
+
+    update_timeout();
+
+    // Re-register all descriptors with epoll.
+    mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
+    for (descriptor_state* state = registered_descriptors_.first();
+        state != 0; state = state->next_)
+    {
+      ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLOUT | EPOLLPRI | EPOLLET;
+      ev.data.ptr = state;
+      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, state->descriptor_, &ev);
+      if (result != 0)
+      {
+        boost::system::error_code ec(errno,
+            boost::asio::error::get_system_category());
+        boost::asio::detail::throw_error(ec, "epoll re-registration");
+      }
+    }
+  }
 }
 
 void epoll_reactor::init_task()
@@ -101,6 +151,7 @@ int epoll_reactor::register_descriptor(socket_type descriptor,
   mutex::scoped_lock lock(registered_descriptors_mutex_);
 
   descriptor_data = registered_descriptors_.alloc();
+  descriptor_data->descriptor_ = descriptor;
   descriptor_data->shutdown_ = false;
 
   lock.unlock();
@@ -115,6 +166,37 @@ int epoll_reactor::register_descriptor(socket_type descriptor,
   return 0;
 }
 
+int epoll_reactor::register_internal_descriptor(
+    int op_type, socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
+{
+  mutex::scoped_lock lock(registered_descriptors_mutex_);
+
+  descriptor_data = registered_descriptors_.alloc();
+  descriptor_data->descriptor_ = descriptor;
+  descriptor_data->shutdown_ = false;
+  descriptor_data->op_queue_[op_type].push(op);
+
+  lock.unlock();
+
+  epoll_event ev = { 0, { 0 } };
+  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLOUT | EPOLLPRI | EPOLLET;
+  ev.data.ptr = descriptor_data;
+  int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
+  if (result != 0)
+    return errno;
+
+  return 0;
+}
+
+void epoll_reactor::move_descriptor(socket_type,
+    epoll_reactor::per_descriptor_data& target_descriptor_data,
+    epoll_reactor::per_descriptor_data& source_descriptor_data)
+{
+  target_descriptor_data = source_descriptor_data;
+  source_descriptor_data = 0;
+}
+
 void epoll_reactor::start_op(int op_type, socket_type descriptor,
     epoll_reactor::per_descriptor_data& descriptor_data,
     reactor_op* op, bool allow_speculative)
@@ -185,8 +267,8 @@ void epoll_reactor::cancel_ops(socket_type,
   io_service_.post_deferred_completions(ops);
 }
 
-void epoll_reactor::close_descriptor(socket_type,
-    epoll_reactor::per_descriptor_data& descriptor_data)
+void epoll_reactor::deregister_descriptor(socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
 {
   if (!descriptor_data)
     return;
@@ -196,8 +278,16 @@ void epoll_reactor::close_descriptor(socket_type,
 
   if (!descriptor_data->shutdown_)
   {
-    // Remove the descriptor from the set of known descriptors. The descriptor
-    // will be automatically removed from the epoll set when it is closed.
+    if (closing)
+    {
+      // The descriptor will be automatically removed from the epoll set when
+      // it is closed.
+    }
+    else
+    {
+      epoll_event ev = { 0, { 0 } };
+      epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
+    }
 
     op_queue<operation> ops;
     for (int i = 0; i < max_ops; ++i)
@@ -210,6 +300,7 @@ void epoll_reactor::close_descriptor(socket_type,
       }
     }
 
+    descriptor_data->descriptor_ = -1;
     descriptor_data->shutdown_ = true;
 
     descriptor_lock.unlock();
@@ -223,6 +314,36 @@ void epoll_reactor::close_descriptor(socket_type,
   }
 }
 
+void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data)
+{
+  if (!descriptor_data)
+    return;
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
+
+  if (!descriptor_data->shutdown_)
+  {
+    epoll_event ev = { 0, { 0 } };
+    epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
+
+    op_queue<operation> ops;
+    for (int i = 0; i < max_ops; ++i)
+      ops.push(descriptor_data->op_queue_[i]);
+
+    descriptor_data->descriptor_ = -1;
+    descriptor_data->shutdown_ = true;
+
+    descriptor_lock.unlock();
+
+    registered_descriptors_.free(descriptor_data);
+    descriptor_data = 0;
+
+    descriptors_lock.unlock();
+  }
+}
+
 void epoll_reactor::run(bool block, op_queue<operation>& ops)
 {
   // Calculate a timeout only if timerfd is not used.
@@ -323,16 +444,53 @@ void epoll_reactor::interrupt()
 
 int epoll_reactor::do_epoll_create()
 {
-  int fd = epoll_create(epoll_size);
+#if defined(EPOLL_CLOEXEC)
+  int fd = epoll_create1(EPOLL_CLOEXEC);
+#else // defined(EPOLL_CLOEXEC)
+  int fd = -1;
+  errno = EINVAL;
+#endif // defined(EPOLL_CLOEXEC)
+
+  if (fd == -1 && errno == EINVAL)
+  {
+    fd = epoll_create(epoll_size);
+    if (fd != -1)
+      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
+  }
+
   if (fd == -1)
   {
     boost::system::error_code ec(errno,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "epoll");
   }
+
   return fd;
 }
 
+int epoll_reactor::do_timerfd_create()
+{
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+# if defined(TFD_CLOEXEC)
+  int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
+# else // defined(TFD_CLOEXEC)
+  int fd = -1;
+  errno = EINVAL;
+# endif // defined(TFD_CLOEXEC)
+
+  if (fd == -1 && errno == EINVAL)
+  {
+    fd = timerfd_create(CLOCK_MONOTONIC, 0);
+    if (fd != -1)
+      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
+  }
+
+  return fd;
+#else // defined(BOOST_ASIO_HAS_TIMERFD)
+  return -1;
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+}
+
 void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(mutex_);
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp
index d270b31..e931eff 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp
@@ -40,24 +40,48 @@ namespace detail {
 
 eventfd_select_interrupter::eventfd_select_interrupter()
 {
+  open_descriptors();
+}
+
+void eventfd_select_interrupter::open_descriptors()
+{
 #if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
   write_descriptor_ = read_descriptor_ = syscall(__NR_eventfd, 0);
-#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-  write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
-#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
   if (read_descriptor_ != -1)
   {
     ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
+    ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
   }
-  else
+#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
+# if defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
+  write_descriptor_ = read_descriptor_ =
+    ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+# else // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
+  errno = EINVAL;
+  write_descriptor_ = read_descriptor_ = -1;
+# endif // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
+  if (read_descriptor_ == -1 && errno == EINVAL)
+  {
+    write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
+    if (read_descriptor_ != -1)
+    {
+      ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
+      ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
+    }
+  }
+#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
+
+  if (read_descriptor_ == -1)
   {
     int pipe_fds[2];
     if (pipe(pipe_fds) == 0)
     {
       read_descriptor_ = pipe_fds[0];
       ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
+      ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
       write_descriptor_ = pipe_fds[1];
       ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
+      ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC);
     }
     else
     {
@@ -70,12 +94,27 @@ eventfd_select_interrupter::eventfd_select_interrupter()
 
 eventfd_select_interrupter::~eventfd_select_interrupter()
 {
+  close_descriptors();
+}
+
+void eventfd_select_interrupter::close_descriptors()
+{
   if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_)
     ::close(write_descriptor_);
   if (read_descriptor_ != -1)
     ::close(read_descriptor_);
 }
 
+void eventfd_select_interrupter::recreate()
+{
+  close_descriptors();
+
+  write_descriptor_ = -1;
+  read_descriptor_ = -1;
+
+  open_descriptors();
+}
+
 void eventfd_select_interrupter::interrupt()
 {
   uint64_t counter(1UL);
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp
new file mode 100644
index 0000000..ec58195
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp
@@ -0,0 +1,299 @@
+//
+// detail/impl/handler_tracking.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_DETAIL_IMPL_HANDLER_TRACKING_IPP
+#define BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+
+#include <cstdarg>
+#include <cstdio>
+#include <boost/asio/detail/handler_tracking.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_WINDOWS)
+# include <unistd.h>
+#endif // !defined(BOOST_WINDOWS)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+struct handler_tracking::tracking_state
+{
+  static_mutex mutex_;
+  boost::uint64_t next_id_;
+  tss_ptr<completion>* current_completion_;
+};
+
+handler_tracking::tracking_state* handler_tracking::get_state()
+{
+  static tracking_state state = { BOOST_ASIO_STATIC_MUTEX_INIT, 1, 0 };
+  return &state;
+}
+
+void handler_tracking::init()
+{
+  static tracking_state* state = get_state();
+
+  state->mutex_.init();
+
+  static_mutex::scoped_lock lock(state->mutex_);
+  if (state->current_completion_ == 0)
+    state->current_completion_ = new tss_ptr<completion>;
+}
+
+void handler_tracking::creation(handler_tracking::tracked_handler* h,
+    const char* object_type, void* object, const char* op_name)
+{
+  static tracking_state* state = get_state();
+
+  static_mutex::scoped_lock lock(state->mutex_);
+  h->id_ = state->next_id_++;
+  lock.unlock();
+
+  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+  boost::posix_time::time_duration now =
+    boost::posix_time::microsec_clock::universal_time() - epoch;
+
+  boost::uint64_t current_id = 0;
+  if (completion* current_completion = *state->current_completion_)
+    current_id = current_completion->id_;
+
+  write_line(
+#if defined(BOOST_WINDOWS)
+      "@asio|%I64u.%06I64u|%I64u*%I64u|%.20s@%p.%.50s\n",
+#else // defined(BOOST_WINDOWS)
+      "@asio|%llu.%06llu|%llu*%llu|%.20s@%p.%.50s\n",
+#endif // defined(BOOST_WINDOWS)
+      static_cast<boost::uint64_t>(now.total_seconds()),
+      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+      current_id, h->id_, object_type, object, op_name);
+}
+
+handler_tracking::completion::completion(handler_tracking::tracked_handler* h)
+  : id_(h->id_),
+    invoked_(false),
+    next_(*get_state()->current_completion_)
+{
+  *get_state()->current_completion_ = this;
+}
+
+handler_tracking::completion::~completion()
+{
+  if (id_)
+  {
+    boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+    boost::posix_time::time_duration now =
+      boost::posix_time::microsec_clock::universal_time() - epoch;
+
+    write_line(
+#if defined(BOOST_WINDOWS)
+        "@asio|%I64u.%06I64u|%c%I64u|\n",
+#else // defined(BOOST_WINDOWS)
+        "@asio|%llu.%06llu|%c%llu|\n",
+#endif // defined(BOOST_WINDOWS)
+        static_cast<boost::uint64_t>(now.total_seconds()),
+        static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+        invoked_ ? '!' : '~', id_);
+  }
+
+  *get_state()->current_completion_ = next_;
+}
+
+void handler_tracking::completion::invocation_begin()
+{
+  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+  boost::posix_time::time_duration now =
+    boost::posix_time::microsec_clock::universal_time() - epoch;
+
+  write_line(
+#if defined(BOOST_WINDOWS)
+      "@asio|%I64u.%06I64u|>%I64u|\n",
+#else // defined(BOOST_WINDOWS)
+      "@asio|%llu.%06llu|>%llu|\n",
+#endif // defined(BOOST_WINDOWS)
+      static_cast<boost::uint64_t>(now.total_seconds()),
+      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), id_);
+
+  invoked_ = true;
+}
+
+void handler_tracking::completion::invocation_begin(
+    const boost::system::error_code& ec)
+{
+  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+  boost::posix_time::time_duration now =
+    boost::posix_time::microsec_clock::universal_time() - epoch;
+
+  write_line(
+#if defined(BOOST_WINDOWS)
+      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d\n",
+#else // defined(BOOST_WINDOWS)
+      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d\n",
+#endif // defined(BOOST_WINDOWS)
+      static_cast<boost::uint64_t>(now.total_seconds()),
+      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+      id_, ec.category().name(), ec.value());
+
+  invoked_ = true;
+}
+
+void handler_tracking::completion::invocation_begin(
+    const boost::system::error_code& ec, std::size_t bytes_transferred)
+{
+  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+  boost::posix_time::time_duration now =
+    boost::posix_time::microsec_clock::universal_time() - epoch;
+
+  write_line(
+#if defined(BOOST_WINDOWS)
+      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,bytes_transferred=%I64u\n",
+#else // defined(BOOST_WINDOWS)
+      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,bytes_transferred=%llu\n",
+#endif // defined(BOOST_WINDOWS)
+      static_cast<boost::uint64_t>(now.total_seconds()),
+      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+      id_, ec.category().name(), ec.value(),
+      static_cast<boost::uint64_t>(bytes_transferred));
+
+  invoked_ = true;
+}
+
+void handler_tracking::completion::invocation_begin(
+    const boost::system::error_code& ec, int signal_number)
+{
+  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+  boost::posix_time::time_duration now =
+    boost::posix_time::microsec_clock::universal_time() - epoch;
+
+  write_line(
+#if defined(BOOST_WINDOWS)
+      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,signal_number=%d\n",
+#else // defined(BOOST_WINDOWS)
+      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,signal_number=%d\n",
+#endif // defined(BOOST_WINDOWS)
+      static_cast<boost::uint64_t>(now.total_seconds()),
+      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+      id_, ec.category().name(), ec.value(), signal_number);
+
+  invoked_ = true;
+}
+
+void handler_tracking::completion::invocation_begin(
+    const boost::system::error_code& ec, const char* arg)
+{
+  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+  boost::posix_time::time_duration now =
+    boost::posix_time::microsec_clock::universal_time() - epoch;
+
+  write_line(
+#if defined(BOOST_WINDOWS)
+      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,%.50s\n",
+#else // defined(BOOST_WINDOWS)
+      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,%.50s\n",
+#endif // defined(BOOST_WINDOWS)
+      static_cast<boost::uint64_t>(now.total_seconds()),
+      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+      id_, ec.category().name(), ec.value(), arg);
+
+  invoked_ = true;
+}
+
+void handler_tracking::completion::invocation_end()
+{
+  if (id_)
+  {
+    boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+    boost::posix_time::time_duration now =
+      boost::posix_time::microsec_clock::universal_time() - epoch;
+
+    write_line(
+#if defined(BOOST_WINDOWS)
+        "@asio|%I64u.%06I64u|<%I64u|\n",
+#else // defined(BOOST_WINDOWS)
+        "@asio|%llu.%06llu|<%llu|\n",
+#endif // defined(BOOST_WINDOWS)
+        static_cast<boost::uint64_t>(now.total_seconds()),
+        static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), id_);
+
+    id_ = 0;
+  }
+}
+
+void handler_tracking::operation(const char* object_type,
+    void* object, const char* op_name)
+{
+  static tracking_state* state = get_state();
+
+  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+  boost::posix_time::time_duration now =
+    boost::posix_time::microsec_clock::universal_time() - epoch;
+
+  unsigned long long current_id = 0;
+  if (completion* current_completion = *state->current_completion_)
+    current_id = current_completion->id_;
+
+  write_line(
+#if defined(BOOST_WINDOWS)
+      "@asio|%I64u.%06I64u|%I64u|%.20s@%p.%.50s\n",
+#else // defined(BOOST_WINDOWS)
+      "@asio|%llu.%06llu|%llu|%.20s@%p.%.50s\n",
+#endif // defined(BOOST_WINDOWS)
+      static_cast<boost::uint64_t>(now.total_seconds()),
+      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+      current_id, object_type, object, op_name);
+}
+
+void handler_tracking::write_line(const char* format, ...)
+{
+  using namespace std; // For sprintf (or equivalent).
+
+  va_list args;
+  va_start(args, format);
+
+  char line[256] = "";
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+  int length = vsprintf_s(line, sizeof(line), format, args);
+#else // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+  int length = vsprintf(line, format, args);
+#endif // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+
+  va_end(args);
+
+#if defined(BOOST_WINDOWS)
+  HANDLE stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE);
+  DWORD bytes_written = 0;
+  ::WriteFile(stderr_handle, line, length, &bytes_written, 0);
+#else // defined(BOOST_WINDOWS)
+  ::write(STDERR_FILENO, line, length);
+#endif // defined(BOOST_WINDOWS)
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
index 779f272..4116997 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
@@ -60,11 +60,12 @@ void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
 
 template <typename Time_Traits>
 std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
index 3ac9eae..f56c4c7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
@@ -75,6 +75,47 @@ void kqueue_reactor::shutdown_service()
   }
 
   timer_queues_.get_all_timers(ops);
+
+  io_service_.abandon_operations(ops);
+}
+
+void kqueue_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
+{
+  if (fork_ev == boost::asio::io_service::fork_child)
+  {
+    // The kqueue descriptor is automatically closed in the child.
+    kqueue_fd_ = -1;
+    kqueue_fd_ = do_kqueue_create();
+
+    interrupter_.recreate();
+
+    // Re-register all descriptors with kqueue.
+    mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
+    for (descriptor_state* state = registered_descriptors_.first();
+        state != 0; state = state->next_)
+    {
+      struct kevent events[2];
+      int num_events = 0;
+
+      if (!state->op_queue_[read_op].empty())
+        BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_,
+            EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, state);
+      else if (!state->op_queue_[except_op].empty())
+        BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_,
+            EVFILT_READ, EV_ADD | EV_CLEAR, EV_OOBAND, 0, state);
+
+      if (!state->op_queue_[write_op].empty())
+        BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_,
+            EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, state);
+
+      if (num_events && ::kevent(kqueue_fd_, events, num_events, 0, 0, 0) == -1)
+      {
+        boost::system::error_code error(errno,
+            boost::asio::error::get_system_category());
+        boost::asio::detail::throw_error(error);
+      }
+    }
+  }
 }
 
 void kqueue_reactor::init_task()
@@ -82,17 +123,58 @@ void kqueue_reactor::init_task()
   io_service_.init_task();
 }
 
-int kqueue_reactor::register_descriptor(socket_type,
+int kqueue_reactor::register_descriptor(socket_type descriptor,
     kqueue_reactor::per_descriptor_data& descriptor_data)
 {
   mutex::scoped_lock lock(registered_descriptors_mutex_);
 
   descriptor_data = registered_descriptors_.alloc();
+  descriptor_data->descriptor_ = descriptor;
   descriptor_data->shutdown_ = false;
 
   return 0;
 }
 
+int kqueue_reactor::register_internal_descriptor(
+    int op_type, socket_type descriptor,
+    kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
+{
+  mutex::scoped_lock lock(registered_descriptors_mutex_);
+
+  descriptor_data = registered_descriptors_.alloc();
+  descriptor_data->descriptor_ = descriptor;
+  descriptor_data->shutdown_ = false;
+  descriptor_data->op_queue_[op_type].push(op);
+
+  struct kevent event;
+  switch (op_type)
+  {
+  case read_op:
+    BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
+        EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
+    break;
+  case write_op:
+    BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
+        EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
+    break;
+  case except_op:
+    BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
+        EV_ADD | EV_CLEAR, EV_OOBAND, 0, descriptor_data);
+    break;
+  }
+  ::kevent(kqueue_fd_, &event, 1, 0, 0, 0);
+
+  return 0;
+}
+
+void kqueue_reactor::move_descriptor(socket_type,
+    kqueue_reactor::per_descriptor_data& target_descriptor_data,
+    kqueue_reactor::per_descriptor_data& source_descriptor_data)
+{
+  target_descriptor_data = source_descriptor_data;
+  source_descriptor_data = 0;
+}
+
 void kqueue_reactor::start_op(int op_type, socket_type descriptor,
     kqueue_reactor::per_descriptor_data& descriptor_data,
     reactor_op* op, bool allow_speculative)
@@ -187,8 +269,8 @@ void kqueue_reactor::cancel_ops(socket_type,
   io_service_.post_deferred_completions(ops);
 }
 
-void kqueue_reactor::close_descriptor(socket_type,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
+void kqueue_reactor::deregister_descriptor(socket_type descriptor,
+    kqueue_reactor::per_descriptor_data& descriptor_data, bool closing)
 {
   if (!descriptor_data)
     return;
@@ -198,8 +280,20 @@ void kqueue_reactor::close_descriptor(socket_type,
 
   if (!descriptor_data->shutdown_)
   {
-    // Remove the descriptor from the set of known descriptors. The descriptor
-    // will be automatically removed from the kqueue set when it is closed.
+    if (closing)
+    {
+      // The descriptor will be automatically removed from the kqueue when it
+      // is closed.
+    }
+    else
+    {
+      struct kevent events[2];
+      BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor,
+          EVFILT_READ, EV_DELETE, 0, 0, 0);
+      BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor,
+          EVFILT_WRITE, EV_DELETE, 0, 0, 0);
+      ::kevent(kqueue_fd_, events, 2, 0, 0, 0);
+    }
 
     op_queue<operation> ops;
     for (int i = 0; i < max_ops; ++i)
@@ -212,6 +306,7 @@ void kqueue_reactor::close_descriptor(socket_type,
       }
     }
 
+    descriptor_data->descriptor_ = -1;
     descriptor_data->shutdown_ = true;
 
     descriptor_lock.unlock();
@@ -225,6 +320,40 @@ void kqueue_reactor::close_descriptor(socket_type,
   }
 }
 
+void kqueue_reactor::deregister_internal_descriptor(socket_type descriptor,
+    kqueue_reactor::per_descriptor_data& descriptor_data)
+{
+  if (!descriptor_data)
+    return;
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
+
+  if (!descriptor_data->shutdown_)
+  {
+    struct kevent events[2];
+    BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor,
+        EVFILT_READ, EV_DELETE, 0, 0, 0);
+    BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor,
+        EVFILT_WRITE, EV_DELETE, 0, 0, 0);
+    ::kevent(kqueue_fd_, events, 2, 0, 0, 0);
+
+    op_queue<operation> ops;
+    for (int i = 0; i < max_ops; ++i)
+      ops.push(descriptor_data->op_queue_[i]);
+
+    descriptor_data->descriptor_ = -1;
+    descriptor_data->shutdown_ = true;
+
+    descriptor_lock.unlock();
+
+    registered_descriptors_.free(descriptor_data);
+    descriptor_data = 0;
+
+    descriptors_lock.unlock();
+  }
+}
+
 void kqueue_reactor::run(bool block, op_queue<operation>& ops)
 {
   mutex::scoped_lock lock(mutex_);
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp
index 9a0a872..59aa053 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp
@@ -38,6 +38,11 @@ namespace detail {
 
 pipe_select_interrupter::pipe_select_interrupter()
 {
+  open_descriptors();
+}
+
+void pipe_select_interrupter::open_descriptors()
+{
   int pipe_fds[2];
   if (pipe(pipe_fds) == 0)
   {
@@ -45,6 +50,11 @@ pipe_select_interrupter::pipe_select_interrupter()
     ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
     write_descriptor_ = pipe_fds[1];
     ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
+
+#if defined(FD_CLOEXEC)
+    ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
+    ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC);
+#endif // defined(FD_CLOEXEC)
   }
   else
   {
@@ -56,12 +66,27 @@ pipe_select_interrupter::pipe_select_interrupter()
 
 pipe_select_interrupter::~pipe_select_interrupter()
 {
+  close_descriptors();
+}
+
+void pipe_select_interrupter::close_descriptors()
+{
   if (read_descriptor_ != -1)
     ::close(read_descriptor_);
   if (write_descriptor_ != -1)
     ::close(write_descriptor_);
 }
 
+void pipe_select_interrupter::recreate()
+{
+  close_descriptors();
+
+  write_descriptor_ = -1;
+  read_descriptor_ = -1;
+
+  open_descriptors();
+}
+
 void pipe_select_interrupter::interrupt()
 {
   char byte = 0;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp
index a1ee09a..38d42be 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp
@@ -46,11 +46,47 @@ void reactive_descriptor_service::construct(
   impl.state_ = 0;
 }
 
+void reactive_descriptor_service::move_construct(
+    reactive_descriptor_service::implementation_type& impl,
+    reactive_descriptor_service::implementation_type& other_impl)
+{
+  impl.descriptor_ = other_impl.descriptor_;
+  other_impl.descriptor_ = -1;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  reactor_.move_descriptor(impl.descriptor_,
+      impl.reactor_data_, other_impl.reactor_data_);
+}
+
+void reactive_descriptor_service::move_assign(
+    reactive_descriptor_service::implementation_type& impl,
+    reactive_descriptor_service& other_service,
+    reactive_descriptor_service::implementation_type& other_impl)
+{
+  destroy(impl);
+
+  impl.descriptor_ = other_impl.descriptor_;
+  other_impl.descriptor_ = -1;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  other_service.reactor_.move_descriptor(impl.descriptor_,
+      impl.reactor_data_, other_impl.reactor_data_);
+}
+
 void reactive_descriptor_service::destroy(
     reactive_descriptor_service::implementation_type& impl)
 {
   if (is_open(impl))
-    reactor_.close_descriptor(impl.descriptor_, impl.reactor_data_);
+  {
+    BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "close"));
+
+    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
+        (impl.state_ & descriptor_ops::possible_dup) == 0);
+  }
 
   boost::system::error_code ignored_ec;
   descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
@@ -58,7 +94,7 @@ void reactive_descriptor_service::destroy(
 
 boost::system::error_code reactive_descriptor_service::assign(
     reactive_descriptor_service::implementation_type& impl,
-    const native_type& native_descriptor, boost::system::error_code& ec)
+    const native_handle_type& native_descriptor, boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
@@ -75,7 +111,7 @@ boost::system::error_code reactive_descriptor_service::assign(
   }
 
   impl.descriptor_ = native_descriptor;
-  impl.state_ = 0;
+  impl.state_ = descriptor_ops::possible_dup;
   ec = boost::system::error_code();
   return ec;
 }
@@ -85,14 +121,43 @@ boost::system::error_code reactive_descriptor_service::close(
     boost::system::error_code& ec)
 {
   if (is_open(impl))
-    reactor_.close_descriptor(impl.descriptor_, impl.reactor_data_);
+  {
+    BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "close"));
 
-  if (descriptor_ops::close(impl.descriptor_, impl.state_, ec) == 0)
-    construct(impl);
+    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
+        (impl.state_ & descriptor_ops::possible_dup) == 0);
+  }
+
+  descriptor_ops::close(impl.descriptor_, impl.state_, ec);
+
+  // The descriptor is closed by the OS even if close() returns an error.
+  //
+  // (Actually, POSIX says the state of the descriptor is unspecified. On
+  // Linux the descriptor is apparently closed anyway; e.g. see
+  //   http://lkml.org/lkml/2005/9/10/129
+  // We'll just have to assume that other OSes follow the same behaviour.)
+  construct(impl);
 
   return ec;
 }
 
+reactive_descriptor_service::native_handle_type
+reactive_descriptor_service::release(
+    reactive_descriptor_service::implementation_type& impl)
+{
+  native_handle_type descriptor = impl.descriptor_;
+
+  if (is_open(impl))
+  {
+    BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "release"));
+
+    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false);
+    construct(impl);
+  }
+
+  return descriptor;
+}
+
 boost::system::error_code reactive_descriptor_service::cancel(
     reactive_descriptor_service::implementation_type& impl,
     boost::system::error_code& ec)
@@ -103,6 +168,8 @@ boost::system::error_code reactive_descriptor_service::cancel(
     return ec;
   }
 
+  BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "cancel"));
+
   reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
   ec = boost::system::error_code();
   return ec;
@@ -110,16 +177,16 @@ boost::system::error_code reactive_descriptor_service::cancel(
 
 void reactive_descriptor_service::start_op(
     reactive_descriptor_service::implementation_type& impl,
-    int op_type, reactor_op* op, bool non_blocking, bool noop)
+    int op_type, reactor_op* op, bool is_non_blocking, bool noop)
 {
   if (!noop)
   {
     if ((impl.state_ & descriptor_ops::non_blocking) ||
         descriptor_ops::set_internal_non_blocking(
-          impl.descriptor_, impl.state_, op->ec_))
+          impl.descriptor_, impl.state_, true, op->ec_))
     {
       reactor_.start_op(op_type, impl.descriptor_,
-          impl.reactor_data_, op, non_blocking);
+          impl.reactor_data_, op, is_non_blocking);
       return;
     }
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp
index ece61d3..f97946f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp
@@ -113,7 +113,7 @@ boost::system::error_code reactive_serial_port_service::do_set_option(
   termios ios;
   errno = 0;
   descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native(impl), &ios), ec);
+        descriptor_service_.native_handle(impl), &ios), ec);
   if (ec)
     return ec;
 
@@ -122,7 +122,7 @@ boost::system::error_code reactive_serial_port_service::do_set_option(
 
   errno = 0;
   descriptor_ops::error_wrapper(::tcsetattr(
-        descriptor_service_.native(impl), TCSANOW, &ios), ec);
+        descriptor_service_.native_handle(impl), TCSANOW, &ios), ec);
   return ec;
 }
 
@@ -134,7 +134,7 @@ boost::system::error_code reactive_serial_port_service::do_get_option(
   termios ios;
   errno = 0;
   descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native(impl), &ios), ec);
+        descriptor_service_.native_handle(impl), &ios), ec);
   if (ec)
     return ec;
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp
index 31f5bc4..0936e92 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp
@@ -45,12 +45,46 @@ void reactive_socket_service_base::construct(
   impl.state_ = 0;
 }
 
+void reactive_socket_service_base::base_move_construct(
+    reactive_socket_service_base::base_implementation_type& impl,
+    reactive_socket_service_base::base_implementation_type& other_impl)
+{
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  reactor_.move_descriptor(impl.socket_,
+      impl.reactor_data_, other_impl.reactor_data_);
+}
+
+void reactive_socket_service_base::base_move_assign(
+    reactive_socket_service_base::base_implementation_type& impl,
+    reactive_socket_service_base& other_service,
+    reactive_socket_service_base::base_implementation_type& other_impl)
+{
+  destroy(impl);
+
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  other_service.reactor_.move_descriptor(impl.socket_,
+      impl.reactor_data_, other_impl.reactor_data_);
+}
+
 void reactive_socket_service_base::destroy(
     reactive_socket_service_base::base_implementation_type& impl)
 {
   if (impl.socket_ != invalid_socket)
   {
-    reactor_.close_descriptor(impl.socket_, impl.reactor_data_);
+    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+
+    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
+        (impl.state_ & socket_ops::possible_dup) == 0);
 
     boost::system::error_code ignored_ec;
     socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
@@ -62,10 +96,24 @@ boost::system::error_code reactive_socket_service_base::close(
     boost::system::error_code& ec)
 {
   if (is_open(impl))
-    reactor_.close_descriptor(impl.socket_, impl.reactor_data_);
+  {
+    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
 
-  if (socket_ops::close(impl.socket_, impl.state_, false, ec) == 0)
-    construct(impl);
+    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
+        (impl.state_ & socket_ops::possible_dup) == 0);
+  }
+
+  socket_ops::close(impl.socket_, impl.state_, false, ec);
+
+  // The descriptor is closed by the OS even if close() returns an error.
+  //
+  // (Actually, POSIX says the state of the descriptor is unspecified. On
+  // Linux the descriptor is apparently closed anyway; e.g. see
+  //   http://lkml.org/lkml/2005/9/10/129
+  // We'll just have to assume that other OSes follow the same behaviour. The
+  // known exception is when Windows's closesocket() function fails with
+  // WSAEWOULDBLOCK, but this case is handled inside socket_ops::close().
+  construct(impl);
 
   return ec;
 }
@@ -80,6 +128,8 @@ boost::system::error_code reactive_socket_service_base::cancel(
     return ec;
   }
 
+  BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "cancel"));
+
   reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
   ec = boost::system::error_code();
   return ec;
@@ -119,7 +169,7 @@ boost::system::error_code reactive_socket_service_base::do_open(
 
 boost::system::error_code reactive_socket_service_base::do_assign(
     reactive_socket_service_base::base_implementation_type& impl, int type,
-    const reactive_socket_service_base::native_type& native_socket,
+    const reactive_socket_service_base::native_handle_type& native_socket,
     boost::system::error_code& ec)
 {
   if (is_open(impl))
@@ -143,22 +193,23 @@ boost::system::error_code reactive_socket_service_base::do_assign(
   case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
   default: impl.state_ = 0; break;
   }
+  impl.state_ |= socket_ops::possible_dup;
   ec = boost::system::error_code();
   return ec;
 }
 
 void reactive_socket_service_base::start_op(
     reactive_socket_service_base::base_implementation_type& impl,
-    int op_type, reactor_op* op, bool non_blocking, bool noop)
+    int op_type, reactor_op* op, bool is_non_blocking, bool noop)
 {
   if (!noop)
   {
     if ((impl.state_ & socket_ops::non_blocking)
         || socket_ops::set_internal_non_blocking(
-          impl.socket_, impl.state_, op->ec_))
+          impl.socket_, impl.state_, true, op->ec_))
     {
       reactor_.start_op(op_type, impl.socket_,
-          impl.reactor_data_, op, non_blocking);
+          impl.reactor_data_, op, is_non_blocking);
       return;
     }
   }
@@ -185,7 +236,7 @@ void reactive_socket_service_base::start_connect_op(
 {
   if ((impl.state_ & socket_ops::non_blocking)
       || socket_ops::set_internal_non_blocking(
-        impl.socket_, impl.state_, op->ec_))
+        impl.socket_, impl.state_, true, op->ec_))
   {
     if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
     {
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp
index e456bb9..2418807 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp
@@ -53,10 +53,10 @@ resolver_service_base::~resolver_service_base()
 void resolver_service_base::shutdown_service()
 {
   work_.reset();
-  if (work_io_service_)
+  if (work_io_service_.get())
   {
     work_io_service_->stop();
-    if (work_thread_)
+    if (work_thread_.get())
     {
       work_thread_->join();
       work_thread_.reset();
@@ -65,6 +65,25 @@ void resolver_service_base::shutdown_service()
   }
 }
 
+void resolver_service_base::fork_service(
+    boost::asio::io_service::fork_event fork_ev)
+{
+  if (work_thread_.get())
+  {
+    if (fork_ev == boost::asio::io_service::fork_prepare)
+    {
+      work_io_service_->stop();
+      work_thread_->join();
+    }
+    else
+    {
+      work_io_service_->reset();
+      work_thread_.reset(new boost::asio::detail::thread(
+            work_io_service_runner(*work_io_service_)));
+    }
+  }
+}
+
 void resolver_service_base::construct(
     resolver_service_base::implementation_type& impl)
 {
@@ -72,13 +91,18 @@ void resolver_service_base::construct(
 }
 
 void resolver_service_base::destroy(
-    resolver_service_base::implementation_type&)
+    resolver_service_base::implementation_type& impl)
 {
+  BOOST_ASIO_HANDLER_OPERATION(("resolver", &impl, "cancel"));
+
+  impl.reset();
 }
 
 void resolver_service_base::cancel(
     resolver_service_base::implementation_type& impl)
 {
+  BOOST_ASIO_HANDLER_OPERATION(("resolver", &impl, "cancel"));
+
   impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
 }
 
@@ -92,7 +116,7 @@ void resolver_service_base::start_resolve_op(operation* op)
 void resolver_service_base::start_work_thread()
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!work_thread_)
+  if (!work_thread_.get())
   {
     work_thread_.reset(new boost::asio::detail::thread(
           work_io_service_runner(*work_io_service_)));
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
index 3773bfb..5ba1806 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
@@ -62,11 +62,12 @@ void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
 
 template <typename Time_Traits>
 std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
index 8fcf68e..7117353 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
@@ -82,6 +82,14 @@ void select_reactor::shutdown_service()
     op_queue_[i].get_all_operations(ops);
 
   timer_queues_.get_all_timers(ops);
+
+  io_service_.abandon_operations(ops);
+}
+
+void select_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
+{
+  if (fork_ev == boost::asio::io_service::fork_child)
+    interrupter_.recreate();
 }
 
 void select_reactor::init_task()
@@ -95,6 +103,24 @@ int select_reactor::register_descriptor(socket_type,
   return 0;
 }
 
+int select_reactor::register_internal_descriptor(
+    int op_type, socket_type descriptor,
+    select_reactor::per_descriptor_data&, reactor_op* op)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+  op_queue_[op_type].enqueue_operation(descriptor, op);
+  interrupter_.interrupt();
+
+  return 0;
+}
+
+void select_reactor::move_descriptor(socket_type,
+    select_reactor::per_descriptor_data&,
+    select_reactor::per_descriptor_data&)
+{
+}
+
 void select_reactor::start_op(int op_type, socket_type descriptor,
     select_reactor::per_descriptor_data&, reactor_op* op, bool)
 {
@@ -119,13 +145,22 @@ void select_reactor::cancel_ops(socket_type descriptor,
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
-void select_reactor::close_descriptor(socket_type descriptor,
-    select_reactor::per_descriptor_data&)
+void select_reactor::deregister_descriptor(socket_type descriptor,
+    select_reactor::per_descriptor_data&, bool)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
+void select_reactor::deregister_internal_descriptor(
+    socket_type descriptor, select_reactor::per_descriptor_data&)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  for (int i = 0; i < max_ops; ++i)
+    op_queue_[i].cancel_operations(descriptor, ops);
+}
+
 void select_reactor::run(bool block, op_queue<operation>& ops)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
index c2f07ec..8c80f6c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/throw_exception.hpp>
+#include <vector>
 #include <boost/asio/detail/service_registry.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -52,6 +53,35 @@ service_registry::~service_registry()
   }
 }
 
+void service_registry::notify_fork(boost::asio::io_service::fork_event fork_ev)
+{
+  // Make a copy of all of the services while holding the lock. We don't want
+  // to hold the lock while calling into each service, as it may try to call
+  // back into this class.
+  std::vector<boost::asio::io_service::service*> services;
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    boost::asio::io_service::service* service = first_service_;
+    while (service)
+    {
+      services.push_back(service);
+      service = service->next_;
+    }
+  }
+
+  // If processing the fork_prepare event, we want to go in reverse order of
+  // service registration, which happens to be the existing order of the
+  // services in the vector. For the other events we want to go in the other
+  // direction.
+  std::size_t num_services = services.size();
+  if (fork_ev == boost::asio::io_service::fork_prepare)
+    for (std::size_t i = 0; i < num_services; ++i)
+      services[i]->fork_service(fork_ev);
+  else
+    for (std::size_t i = num_services; i > 0; --i)
+      services[i - 1]->fork_service(fork_ev);
+}
+
 void service_registry::init_key(boost::asio::io_service::service::key& key,
     const boost::asio::io_service::id& id)
 {
@@ -121,7 +151,7 @@ void service_registry::do_add_service(
     const boost::asio::io_service::service::key& key,
     boost::asio::io_service::service* new_service)
 {
-  if (&owner_ != &new_service->io_service())
+  if (&owner_ != &new_service->get_io_service())
     boost::throw_exception(invalid_service_owner());
 
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp
new file mode 100644
index 0000000..c1dedd4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp
@@ -0,0 +1,592 @@
+//
+// detail/impl/signal_set_service.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_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_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 <boost/asio/detail/reactor.hpp>
+#include <boost/asio/detail/signal_blocker.hpp>
+#include <boost/asio/detail/signal_set_service.hpp>
+#include <boost/asio/detail/static_mutex.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+struct signal_state
+{
+  // Mutex used for protecting global state.
+  static_mutex mutex_;
+
+  // The read end of the pipe used for signal notifications.
+  int read_descriptor_;
+
+  // The write end of the pipe used for signal notifications.
+  int write_descriptor_;
+
+  // Whether the signal state has been prepared for a fork.
+  bool fork_prepared_;
+
+  // The head of a linked list of all signal_set_service instances.
+  class signal_set_service* service_list_;
+
+  // A count of the number of objects that are registered for each signal.
+  std::size_t registration_count_[max_signal_number];
+};
+
+signal_state* get_signal_state()
+{
+  static signal_state state = {
+    BOOST_ASIO_STATIC_MUTEX_INIT, -1, -1, false, 0, { 0 } };
+  return &state;
+}
+
+void asio_signal_handler(int signal_number)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  signal_set_service::deliver_signal(signal_number);
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  int saved_errno = errno;
+  signal_state* state = get_signal_state();
+  int result = ::write(state->write_descriptor_,
+      &signal_number, sizeof(signal_number));
+  (void)result;
+  errno = saved_errno;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#if defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION)
+  signal(signal_number, asio_signal_handler);
+#endif // defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION)
+}
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+class signal_set_service::pipe_read_op : public reactor_op
+{
+public:
+  pipe_read_op()
+    : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete)
+  {
+  }
+
+  static bool do_perform(reactor_op*)
+  {
+    signal_state* state = get_signal_state();
+
+    int fd = state->read_descriptor_;
+    int signal_number = 0;
+    while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
+      if (signal_number >= 0 && signal_number < max_signal_number)
+        signal_set_service::deliver_signal(signal_number);
+
+    return false;
+  }
+
+  static void do_complete(io_service_impl* /*owner*/, operation* base,
+      boost::system::error_code /*ec*/, std::size_t /*bytes_transferred*/)
+  {
+    pipe_read_op* o(static_cast<pipe_read_op*>(base));
+    delete o;
+  }
+};
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+signal_set_service::signal_set_service(
+    boost::asio::io_service& io_service)
+  : io_service_(boost::asio::use_service<io_service_impl>(io_service)),
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+    reactor_(boost::asio::use_service<reactor>(io_service)),
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+    next_(0),
+    prev_(0)
+{
+  get_signal_state()->mutex_.init();
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  reactor_.init_task();
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+  for (int i = 0; i < max_signal_number; ++i)
+    registrations_[i] = 0;
+
+  add_service(this);
+}
+
+signal_set_service::~signal_set_service()
+{
+  remove_service(this);
+}
+
+void signal_set_service::shutdown_service()
+{
+  remove_service(this);
+
+  op_queue<operation> ops;
+
+  for (int i = 0; i < max_signal_number; ++i)
+  {
+    registration* reg = registrations_[i];
+    while (reg)
+    {
+      ops.push(*reg->queue_);
+      reg = reg->next_in_table_;
+    }
+  }
+
+  io_service_.abandon_operations(ops);
+}
+
+void signal_set_service::fork_service(
+    boost::asio::io_service::fork_event fork_ev)
+{
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+  switch (fork_ev)
+  {
+  case boost::asio::io_service::fork_prepare:
+    reactor_.deregister_internal_descriptor(
+        state->read_descriptor_, reactor_data_);
+    state->fork_prepared_ = true;
+    break;
+  case boost::asio::io_service::fork_parent:
+    state->fork_prepared_ = false;
+    reactor_.register_internal_descriptor(reactor::read_op,
+        state->read_descriptor_, reactor_data_, new pipe_read_op);
+    break;
+  case boost::asio::io_service::fork_child:
+    if (state->fork_prepared_)
+    {
+      boost::asio::detail::signal_blocker blocker;
+      close_descriptors();
+      open_descriptors();
+      state->fork_prepared_ = false;
+    }
+    reactor_.register_internal_descriptor(reactor::read_op,
+        state->read_descriptor_, reactor_data_, new pipe_read_op);
+    break;
+  default:
+    break;
+  }
+#else // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  (void)fork_ev;
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+}
+
+void signal_set_service::construct(
+    signal_set_service::implementation_type& impl)
+{
+  impl.signals_ = 0;
+}
+
+void signal_set_service::destroy(
+    signal_set_service::implementation_type& impl)
+{
+  boost::system::error_code ignored_ec;
+  clear(impl, ignored_ec);
+  cancel(impl, ignored_ec);
+}
+
+boost::system::error_code signal_set_service::add(
+    signal_set_service::implementation_type& impl,
+    int signal_number, boost::system::error_code& ec)
+{
+  // Check that the signal number is valid.
+  if (signal_number < 0 || signal_number > max_signal_number)
+  {
+    ec = boost::asio::error::invalid_argument;
+    return ec;
+  }
+
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+  // Find the appropriate place to insert the registration.
+  registration** insertion_point = &impl.signals_;
+  registration* next = impl.signals_;
+  while (next && next->signal_number_ < signal_number)
+  {
+    insertion_point = &next->next_in_set_;
+    next = next->next_in_set_;
+  }
+
+  // Only do something if the signal is not already registered.
+  if (next == 0 || next->signal_number_ != signal_number)
+  {
+    registration* new_registration = new registration;
+
+#if defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
+    // Register for the signal if we're the first.
+    if (state->registration_count_[signal_number] == 0)
+    {
+# if defined(BOOST_ASIO_HAS_SIGACTION)
+      using namespace std; // For memset.
+      struct sigaction sa;
+      memset(&sa, 0, sizeof(sa));
+      sa.sa_handler = asio_signal_handler;
+      sigfillset(&sa.sa_mask);
+      if (::sigaction(signal_number, &sa, 0) == -1)
+# else // defined(BOOST_ASIO_HAS_SIGACTION)
+      if (::signal(signal_number, asio_signal_handler) == SIG_ERR)
+# endif // defined(BOOST_ASIO_HAS_SIGACTION)
+      {
+# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        ec = boost::asio::error::invalid_argument;
+# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        ec = boost::system::error_code(errno,
+            boost::asio::error::get_system_category());
+# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        delete new_registration;
+        return ec;
+      }
+    }
+#endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
+
+    // Record the new registration in the set.
+    new_registration->signal_number_ = signal_number;
+    new_registration->queue_ = &impl.queue_;
+    new_registration->next_in_set_ = next;
+    *insertion_point = new_registration;
+
+    // Insert registration into the registration table.
+    new_registration->next_in_table_ = registrations_[signal_number];
+    if (registrations_[signal_number])
+      registrations_[signal_number]->prev_in_table_ = new_registration;
+    registrations_[signal_number] = new_registration;
+
+    ++state->registration_count_[signal_number];
+  }
+
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code signal_set_service::remove(
+    signal_set_service::implementation_type& impl,
+    int signal_number, boost::system::error_code& ec)
+{
+  // Check that the signal number is valid.
+  if (signal_number < 0 || signal_number > max_signal_number)
+  {
+    ec = boost::asio::error::invalid_argument;
+    return ec;
+  }
+
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+  // Find the signal number in the list of registrations.
+  registration** deletion_point = &impl.signals_;
+  registration* reg = impl.signals_;
+  while (reg && reg->signal_number_ < signal_number)
+  {
+    deletion_point = &reg->next_in_set_;
+    reg = reg->next_in_set_;
+  }
+
+  if (reg != 0 && reg->signal_number_ == signal_number)
+  {
+#if defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
+    // Set signal handler back to the default if we're the last.
+    if (state->registration_count_[signal_number] == 1)
+    {
+# if defined(BOOST_ASIO_HAS_SIGACTION)
+      using namespace std; // For memset.
+      struct sigaction sa;
+      memset(&sa, 0, sizeof(sa));
+      sa.sa_handler = SIG_DFL;
+      if (::sigaction(signal_number, &sa, 0) == -1)
+# else // defined(BOOST_ASIO_HAS_SIGACTION)
+      if (::signal(signal_number, SIG_DFL) == SIG_ERR)
+# endif // defined(BOOST_ASIO_HAS_SIGACTION)
+      {
+# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        ec = boost::asio::error::invalid_argument;
+# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        ec = boost::system::error_code(errno,
+            boost::asio::error::get_system_category());
+# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        return ec;
+      }
+    }
+#endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
+
+    // Remove the registration from the set.
+    *deletion_point = reg->next_in_set_;
+
+    // Remove the registration from the registration table.
+    if (registrations_[signal_number] == reg)
+      registrations_[signal_number] = reg->next_in_table_;
+    if (reg->prev_in_table_)
+      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
+    if (reg->next_in_table_)
+      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
+
+    --state->registration_count_[signal_number];
+
+    delete reg;
+  }
+
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code signal_set_service::clear(
+    signal_set_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+  while (registration* reg = impl.signals_)
+  {
+#if defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
+    // Set signal handler back to the default if we're the last.
+    if (state->registration_count_[reg->signal_number_] == 1)
+    {
+# if defined(BOOST_ASIO_HAS_SIGACTION)
+      using namespace std; // For memset.
+      struct sigaction sa;
+      memset(&sa, 0, sizeof(sa));
+      sa.sa_handler = SIG_DFL;
+      if (::sigaction(reg->signal_number_, &sa, 0) == -1)
+# else // defined(BOOST_ASIO_HAS_SIGACTION)
+      if (::signal(reg->signal_number_, SIG_DFL) == SIG_ERR)
+# endif // defined(BOOST_ASIO_HAS_SIGACTION)
+      {
+# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        ec = boost::asio::error::invalid_argument;
+# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        ec = boost::system::error_code(errno,
+            boost::asio::error::get_system_category());
+# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+        return ec;
+      }
+    }
+#endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
+
+    // Remove the registration from the registration table.
+    if (registrations_[reg->signal_number_] == reg)
+      registrations_[reg->signal_number_] = reg->next_in_table_;
+    if (reg->prev_in_table_)
+      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
+    if (reg->next_in_table_)
+      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
+
+    --state->registration_count_[reg->signal_number_];
+
+    impl.signals_ = reg->next_in_set_;
+    delete reg;
+  }
+
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code signal_set_service::cancel(
+    signal_set_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  BOOST_ASIO_HANDLER_OPERATION(("signal_set", &impl, "cancel"));
+
+  op_queue<operation> ops;
+  {
+    signal_state* state = get_signal_state();
+    static_mutex::scoped_lock lock(state->mutex_);
+
+    while (signal_op* op = impl.queue_.front())
+    {
+      op->ec_ = boost::asio::error::operation_aborted;
+      impl.queue_.pop();
+      ops.push(op);
+    }
+  }
+
+  io_service_.post_deferred_completions(ops);
+
+  ec = boost::system::error_code();
+  return ec;
+}
+
+void signal_set_service::deliver_signal(int signal_number)
+{
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+  signal_set_service* service = state->service_list_;
+  while (service)
+  {
+    op_queue<operation> ops;
+
+    registration* reg = service->registrations_[signal_number];
+    while (reg)
+    {
+      if (reg->queue_->empty())
+      {
+        ++reg->undelivered_;
+      }
+      else
+      {
+        while (signal_op* op = reg->queue_->front())
+        {
+          op->signal_number_ = signal_number;
+          reg->queue_->pop();
+          ops.push(op);
+        }
+      }
+
+      reg = reg->next_in_table_;
+    }
+
+    service->io_service_.post_deferred_completions(ops);
+
+    service = service->next_;
+  }
+}
+
+void signal_set_service::add_service(signal_set_service* service)
+{
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  // If this is the first service to be created, open a new pipe.
+  if (state->service_list_ == 0)
+    open_descriptors();
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+  // Insert service into linked list of all services.
+  service->next_ = state->service_list_;
+  service->prev_ = 0;
+  if (state->service_list_)
+    state->service_list_->prev_ = service;
+  state->service_list_ = service;
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  // Register for pipe readiness notifications.
+  service->reactor_.register_internal_descriptor(reactor::read_op,
+      state->read_descriptor_, service->reactor_data_, new pipe_read_op);
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+}
+
+void signal_set_service::remove_service(signal_set_service* service)
+{
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+  if (service->next_ || service->prev_ || state->service_list_ == service)
+  {
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+    // Disable the pipe readiness notifications.
+    service->reactor_.deregister_descriptor(
+        state->read_descriptor_, service->reactor_data_, false);
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+    // Remove service from linked list of all services.
+    if (state->service_list_ == service)
+      state->service_list_ = service->next_;
+    if (service->prev_)
+      service->prev_->next_ = service->next_;
+    if (service->next_)
+      service->next_->prev_= service->prev_;
+    service->next_ = 0;
+    service->prev_ = 0;
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+    // If this is the last service to be removed, close the pipe.
+    if (state->service_list_ == 0)
+      close_descriptors();
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  }
+}
+
+void signal_set_service::open_descriptors()
+{
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  signal_state* state = get_signal_state();
+
+  int pipe_fds[2];
+  if (::pipe(pipe_fds) == 0)
+  {
+    state->read_descriptor_ = pipe_fds[0];
+    ::fcntl(state->read_descriptor_, F_SETFL, O_NONBLOCK);
+
+    state->write_descriptor_ = pipe_fds[1];
+    ::fcntl(state->write_descriptor_, F_SETFL, O_NONBLOCK);
+
+#if defined(FD_CLOEXEC)
+    ::fcntl(state->read_descriptor_, F_SETFD, FD_CLOEXEC);
+    ::fcntl(state->write_descriptor_, F_SETFD, FD_CLOEXEC);
+#endif // defined(FD_CLOEXEC)
+  }
+  else
+  {
+    boost::system::error_code ec(errno,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(ec, "signal_set_service pipe");
+  }
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+}
+
+void signal_set_service::close_descriptors()
+{
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  signal_state* state = get_signal_state();
+
+  if (state->read_descriptor_ != -1)
+    ::close(state->read_descriptor_);
+  state->read_descriptor_ = -1;
+
+  if (state->write_descriptor_ != -1)
+    ::close(state->write_descriptor_);
+  state->write_descriptor_ = -1;
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+}
+
+void signal_set_service::start_wait_op(
+    signal_set_service::implementation_type& impl, signal_op* op)
+{
+  io_service_.work_started();
+
+  signal_state* state = get_signal_state();
+  static_mutex::scoped_lock lock(state->mutex_);
+
+  registration* reg = impl.signals_;
+  while (reg)
+  {
+    if (reg->undelivered_ > 0)
+    {
+      --reg->undelivered_;
+      io_service_.post_deferred_completion(op);
+      return;
+    }
+
+    reg = reg->next_in_set_;
+  }
+
+  impl.queue_.push(op);
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
index e240acd..55b6348 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
@@ -278,28 +278,9 @@ int close(socket_type s, state_type& state,
   int result = 0;
   if (s != invalid_socket)
   {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-    if ((state & non_blocking) && (state & user_set_linger))
-    {
-      ioctl_arg_type arg = 0;
-      ::ioctlsocket(s, FIONBIO, &arg);
-      state &= ~non_blocking;
-    }
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-    if (state & non_blocking)
-    {
-#if defined(__SYMBIAN32__)
-      int flags = ::fcntl(s, F_GETFL, 0);
-      if (flags >= 0)
-        ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
-#else // defined(__SYMBIAN32__)
-      ioctl_arg_type arg = 0;
-      ::ioctl(s, FIONBIO, &arg);
-#endif // defined(__SYMBIAN32__)
-      state &= ~non_blocking;
-    }
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
+    // We don't want the destructor to block, so set the socket to linger in
+    // the background. If the user doesn't like this behaviour then they need
+    // to explicitly close the socket.
     if (destruction && (state & user_set_linger))
     {
       ::linger opt;
@@ -316,6 +297,39 @@ int close(socket_type s, state_type& state,
 #else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
     result = error_wrapper(::close(s), ec);
 #endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+    if (result != 0
+        && (ec == boost::asio::error::would_block
+          || ec == boost::asio::error::try_again))
+    {
+      // According to UNIX Network Programming Vol. 1, it is possible for
+      // close() to fail with EWOULDBLOCK under certain circumstances. What
+      // isn't clear is the state of the descriptor after this error. The one
+      // current OS where this behaviour is seen, Windows, says that the socket
+      // remains open. Therefore we'll put the descriptor back into blocking
+      // mode and have another attempt at closing it.
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+      ioctl_arg_type arg = 0;
+      ::ioctlsocket(s, FIONBIO, &arg);
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(__SYMBIAN32__)
+      int flags = ::fcntl(s, F_GETFL, 0);
+      if (flags >= 0)
+        ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
+# else // defined(__SYMBIAN32__)
+      ioctl_arg_type arg = 0;
+      ::ioctl(s, FIONBIO, &arg);
+# endif // defined(__SYMBIAN32__)
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+      state &= ~non_blocking;
+
+      clear_last_error();
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+      result = error_wrapper(::closesocket(s), ec);
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+      result = error_wrapper(::close(s), ec);
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+    }
   }
 
   if (result == 0)
@@ -323,8 +337,52 @@ int close(socket_type s, state_type& state,
   return result;
 }
 
+bool set_user_non_blocking(socket_type s,
+    state_type& state, bool value, boost::system::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return false;
+  }
+
+  clear_last_error();
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  ioctl_arg_type arg = (value ? 1 : 0);
+  int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
+#elif defined(__SYMBIAN32__)
+  int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
+  if (result >= 0)
+  {
+    clear_last_error();
+    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
+  }
+#else
+  ioctl_arg_type arg = (value ? 1 : 0);
+  int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
+#endif
+
+  if (result >= 0)
+  {
+    ec = boost::system::error_code();
+    if (value)
+      state |= user_set_non_blocking;
+    else
+    {
+      // Clearing the user-set non-blocking mode always overrides any
+      // internally-set non-blocking flag. Any subsequent asynchronous
+      // operations will need to re-enable non-blocking I/O.
+      state &= ~(user_set_non_blocking | internal_non_blocking);
+    }
+    return true;
+  }
+
+  return false;
+}
+
 bool set_internal_non_blocking(socket_type s,
-    state_type& state, boost::system::error_code& ec)
+    state_type& state, bool value, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
@@ -332,26 +390,39 @@ bool set_internal_non_blocking(socket_type s,
     return false;
   }
 
+  if (!value && (state & user_set_non_blocking))
+  {
+    // It does not make sense to clear the internal non-blocking flag if the
+    // user still wants non-blocking behaviour. Return an error and let the
+    // caller figure out whether to update the user-set non-blocking flag.
+    ec = boost::asio::error::invalid_argument;
+    return false;
+  }
+
   clear_last_error();
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  ioctl_arg_type arg = 1;
+  ioctl_arg_type arg = (value ? 1 : 0);
   int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
 #elif defined(__SYMBIAN32__)
   int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
   if (result >= 0)
   {
     clear_last_error();
-    result = error_wrapper(::fcntl(s, F_SETFL, result | O_NONBLOCK), ec);
+    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
   }
 #else
-  ioctl_arg_type arg = 1;
+  ioctl_arg_type arg = (value ? 1 : 0);
   int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
 #endif
 
   if (result >= 0)
   {
     ec = boost::system::error_code();
-    state |= internal_non_blocking;
+    if (value)
+      state |= internal_non_blocking;
+    else
+      state &= ~internal_non_blocking;
     return true;
   }
 
@@ -863,6 +934,116 @@ bool non_blocking_recvfrom(socket_type s,
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
+int recvmsg(socket_type s, buf* bufs, size_t count,
+    int in_flags, int& out_flags, boost::system::error_code& ec)
+{
+  clear_last_error();
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  out_flags = 0;
+  return socket_ops::recv(s, bufs, count, in_flags, ec);
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg = msghdr();
+  msg.msg_iov = bufs;
+  msg.msg_iovlen = count;
+  int result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
+  if (result >= 0)
+  {
+    ec = boost::system::error_code();
+    out_flags = msg.msg_flags;
+  }
+  else
+    out_flags = 0;
+  return result;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+size_t sync_recvmsg(socket_type s, state_type state,
+    buf* bufs, size_t count, int in_flags, int& out_flags,
+    boost::system::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return 0;
+  }
+
+  // Read some data.
+  for (;;)
+  {
+    // Try to complete the operation without blocking.
+    int bytes = socket_ops::recvmsg(s, bufs, count, in_flags, out_flags, ec);
+
+    // Check if operation succeeded.
+    if (bytes >= 0)
+      return bytes;
+
+    // Operation failed.
+    if ((state & user_set_non_blocking)
+        || (ec != boost::asio::error::would_block
+          && ec != boost::asio::error::try_again))
+      return 0;
+
+    // Wait for socket to become ready.
+    if (socket_ops::poll_read(s, ec) < 0)
+      return 0;
+  }
+}
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+void complete_iocp_recvmsg(
+    const weak_cancel_token_type& cancel_token,
+    boost::system::error_code& ec)
+{
+  // Map non-portable errors to their portable counterparts.
+  if (ec.value() == ERROR_NETNAME_DELETED)
+  {
+    if (cancel_token.expired())
+      ec = boost::asio::error::operation_aborted;
+    else
+      ec = boost::asio::error::connection_reset;
+  }
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+  {
+    ec = boost::asio::error::connection_refused;
+  }
+}
+
+#else // defined(BOOST_ASIO_HAS_IOCP)
+
+bool non_blocking_recvmsg(socket_type s,
+    buf* bufs, size_t count, int in_flags, int& out_flags,
+    boost::system::error_code& ec, size_t& bytes_transferred)
+{
+  for (;;)
+  {
+    // Read some data.
+    int bytes = socket_ops::recvmsg(s, bufs, count, in_flags, out_flags, ec);
+
+    // Retry operation if interrupted by signal.
+    if (ec == boost::asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == boost::asio::error::would_block
+        || ec == boost::asio::error::try_again)
+      return false;
+
+    // Operation is complete.
+    if (bytes >= 0)
+    {
+      ec = boost::system::error_code();
+      bytes_transferred = bytes;
+    }
+    else
+      bytes_transferred = 0;
+
+    return true;
+  }
+}
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
 int send(socket_type s, const buf* bufs, size_t count, int flags,
     boost::system::error_code& ec)
 {
@@ -1680,7 +1861,8 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
     using namespace std; // For strcat and sprintf.
     char if_name[IF_NAMESIZE + 1] = "%";
     const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
-    bool is_link_local = IN6_IS_ADDR_LINKLOCAL(ipv6_address);
+    bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
+        && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
     if (!is_link_local || if_indextoname(scope_id, if_name + 1) == 0)
       sprintf(if_name + 1, "%lu", scope_id);
     strcat(dest, if_name);
@@ -1764,7 +1946,8 @@ int inet_pton(int af, const char* src, void* dest,
     if (const char* if_name = strchr(src, '%'))
     {
       in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
-      bool is_link_local = IN6_IS_ADDR_LINKLOCAL(ipv6_address);
+      bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
+          && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
       if (is_link_local)
         *scope_id = if_nametoindex(if_name + 1);
       if (*scope_id == 0)
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp
index 3b64771..533bafd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp
@@ -36,6 +36,11 @@ namespace detail {
 
 socket_select_interrupter::socket_select_interrupter()
 {
+  open_descriptors();
+}
+
+void socket_select_interrupter::open_descriptors()
+{
   boost::system::error_code ec;
   socket_holder acceptor(socket_ops::socket(
         AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
@@ -110,6 +115,11 @@ socket_select_interrupter::socket_select_interrupter()
 
 socket_select_interrupter::~socket_select_interrupter()
 {
+  close_descriptors();
+}
+
+void socket_select_interrupter::close_descriptors()
+{
   boost::system::error_code ec;
   socket_ops::state_type state = socket_ops::internal_non_blocking;
   if (read_descriptor_ != invalid_socket)
@@ -118,6 +128,16 @@ socket_select_interrupter::~socket_select_interrupter()
     socket_ops::close(write_descriptor_, state, true, ec);
 }
 
+void socket_select_interrupter::recreate()
+{
+  close_descriptors();
+
+  write_descriptor_ = invalid_socket;
+  read_descriptor_ = invalid_socket;
+
+  open_descriptors();
+}
+
 void socket_select_interrupter::interrupt()
 {
   char byte = 0;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
index 5cb320d..bb3698a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
@@ -73,19 +73,14 @@ void strand_service::dispatch(strand_service::implementation_type& impl,
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
-  // If we are running inside the io_service, and no other handler is queued
-  // or running, then the handler can run immediately.
-  bool can_dispatch = call_stack<io_service_impl>::contains(&io_service_);
-  impl->mutex_.lock();
-  bool first = (++impl->count_ == 1);
-  if (can_dispatch && first)
-  {
-    // Immediate invocation is allowed.
-    impl->mutex_.unlock();
+  BOOST_ASIO_HANDLER_CREATION((p.p, "strand", impl, "dispatch"));
 
-    // Memory must be releaesed before any upcall is made.
-    p.reset();
+  bool dispatch_immediately = do_dispatch(impl, p.p);
+  operation* o = p.p;
+  p.v = p.p = 0;
 
+  if (dispatch_immediately)
+  {
     // Indicate that this strand is executing on the current thread.
     call_stack<strand_impl>::context ctx(impl);
 
@@ -93,20 +88,9 @@ void strand_service::dispatch(strand_service::implementation_type& impl,
     on_dispatch_exit on_exit = { &io_service_, impl };
     (void)on_exit;
 
-    boost::asio::detail::fenced_block b;
-    boost_asio_handler_invoke_helpers::invoke(handler, handler);
-    return;
+    completion_handler<Handler>::do_complete(
+        &io_service_, o, boost::system::error_code(), 0);
   }
-
-  // Immediate invocation is not allowed, so enqueue for later.
-  impl->queue_.push(p.p);
-  impl->mutex_.unlock();
-  p.v = p.p = 0;
-
-  // The first handler to be enqueued is responsible for scheduling the
-  // strand.
-  if (first)
-    io_service_.post_immediate_completion(impl);
 }
 
 // Request the io_service to invoke the given handler and return immediately.
@@ -121,16 +105,10 @@ void strand_service::post(strand_service::implementation_type& impl,
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
-  // Add the handler to the queue.
-  impl->mutex_.lock();
-  bool first = (++impl->count_ == 1);
-  impl->queue_.push(p.p);
-  impl->mutex_.unlock();
-  p.v = p.p = 0;
+  BOOST_ASIO_HANDLER_CREATION((p.p, "strand", impl, "post"));
 
-  // The first handler to be enqueue is responsible for scheduling the strand.
-  if (first)
-    io_service_.post_immediate_completion(impl);
+  do_post(impl, p.p);
+  p.v = p.p = 0;
 }
 
 } // namespace detail
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
index 6a42146..62a8d5c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
@@ -70,11 +70,50 @@ void strand_service::construct(strand_service::implementation_type& impl)
 
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
-  if (!implementations_[index])
+  if (!implementations_[index].get())
     implementations_[index].reset(new strand_impl);
   impl = implementations_[index].get();
 }
 
+bool strand_service::do_dispatch(implementation_type& impl, operation* op)
+{
+  // If we are running inside the io_service, and no other handler is queued
+  // or running, then the handler can run immediately.
+  bool can_dispatch = call_stack<io_service_impl>::contains(&io_service_);
+  impl->mutex_.lock();
+  bool first = (++impl->count_ == 1);
+  if (can_dispatch && first)
+  {
+    // Immediate invocation is allowed.
+    impl->mutex_.unlock();
+    return true;
+  }
+
+  // Immediate invocation is not allowed, so enqueue for later.
+  impl->queue_.push(op);
+  impl->mutex_.unlock();
+
+  // The first handler to be enqueued is responsible for scheduling the
+  // strand.
+  if (first)
+    io_service_.post_immediate_completion(impl);
+
+  return false;
+}
+
+void strand_service::do_post(implementation_type& impl, operation* op)
+{
+  // Add the handler to the queue.
+  impl->mutex_.lock();
+  bool first = (++impl->count_ == 1);
+  impl->queue_.push(op);
+  impl->mutex_.unlock();
+
+  // The first handler to be enqueue is responsible for scheduling the strand.
+  if (first)
+    io_service_.post_immediate_completion(impl);
+}
+
 void strand_service::do_complete(io_service_impl* owner, operation* base,
     boost::system::error_code /*ec*/, std::size_t /*bytes_transferred*/)
 {
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp
index a002189..ee23cb9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp
@@ -36,7 +36,19 @@ void task_io_service::dispatch(Handler handler)
     boost_asio_handler_invoke_helpers::invoke(handler, handler);
   }
   else
-    post(handler);
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef completion_handler<Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch"));
+
+    post_immediate_completion(p.p);
+    p.v = p.p = 0;
+  }
 }
 
 template <typename Handler>
@@ -49,6 +61,8 @@ void task_io_service::post(Handler handler)
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
+  BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "post"));
+
   post_immediate_completion(p.p);
   p.v = p.p = 0;
 }
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp
index babfa7b..5b1d069 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp
@@ -74,6 +74,7 @@ task_io_service::task_io_service(boost::asio::io_service& io_service)
     shutdown_(false),
     first_idle_thread_(0)
 {
+  BOOST_ASIO_HANDLER_TRACKING_INIT;
 }
 
 void task_io_service::init(std::size_t /*concurrency_hint*/)
@@ -194,6 +195,12 @@ void task_io_service::stop()
   stop_all_threads(lock);
 }
 
+bool task_io_service::stopped() const
+{
+  mutex::scoped_lock lock(mutex_);
+  return stopped_;
+}
+
 void task_io_service::reset()
 {
   mutex::scoped_lock lock(mutex_);
@@ -224,6 +231,13 @@ void task_io_service::post_deferred_completions(
   }
 }
 
+void task_io_service::abandon_operations(
+    op_queue<task_io_service::operation>& ops)
+{
+  op_queue<task_io_service::operation> ops2;
+  ops2.push(ops);
+}
+
 std::size_t task_io_service::do_one(mutex::scoped_lock& lock,
     task_io_service::idle_thread_info* this_idle_thread)
 {
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp
index eb6643a..b525e06 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp
@@ -100,6 +100,64 @@ void win_iocp_handle_service::construct(
   impl_list_ = &impl;
 }
 
+void win_iocp_handle_service::move_construct(
+    win_iocp_handle_service::implementation_type& impl,
+    win_iocp_handle_service::implementation_type& other_impl)
+{
+  impl.handle_ = other_impl.handle_;
+  other_impl.handle_ = INVALID_HANDLE_VALUE;
+
+  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
+  other_impl.safe_cancellation_thread_id_ = 0;
+
+  // Insert implementation into linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void win_iocp_handle_service::move_assign(
+    win_iocp_handle_service::implementation_type& impl,
+    win_iocp_handle_service& other_service,
+    win_iocp_handle_service::implementation_type& other_impl)
+{
+  close_for_destruction(impl);
+
+  if (this != &other_service)
+  {
+    // Remove implementation from linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  impl.handle_ = other_impl.handle_;
+  other_impl.handle_ = INVALID_HANDLE_VALUE;
+
+  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
+  other_impl.safe_cancellation_thread_id_ = 0;
+
+  if (this != &other_service)
+  {
+    // Insert implementation into linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_);
+    impl.next_ = other_service.impl_list_;
+    impl.prev_ = 0;
+    if (other_service.impl_list_)
+      other_service.impl_list_->prev_ = &impl;
+    other_service.impl_list_ = &impl;
+  }
+}
+
 void win_iocp_handle_service::destroy(
     win_iocp_handle_service::implementation_type& impl)
 {
@@ -119,7 +177,7 @@ void win_iocp_handle_service::destroy(
 
 boost::system::error_code win_iocp_handle_service::assign(
     win_iocp_handle_service::implementation_type& impl,
-    const native_type& native_handle, boost::system::error_code& ec)
+    const native_handle_type& handle, boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
@@ -127,10 +185,10 @@ boost::system::error_code win_iocp_handle_service::assign(
     return ec;
   }
 
-  if (iocp_service_.register_handle(native_handle, ec))
+  if (iocp_service_.register_handle(handle, ec))
     return ec;
 
-  impl.handle_ = native_handle;
+  impl.handle_ = handle;
   ec = boost::system::error_code();
   return ec;
 }
@@ -141,19 +199,27 @@ boost::system::error_code win_iocp_handle_service::close(
 {
   if (is_open(impl))
   {
+    BOOST_ASIO_HANDLER_OPERATION(("handle", &impl, "close"));
+
     if (!::CloseHandle(impl.handle_))
     {
       DWORD last_error = ::GetLastError();
       ec = boost::system::error_code(last_error,
           boost::asio::error::get_system_category());
-      return ec;
+    }
+    else
+    {
+      ec = boost::system::error_code();
     }
 
     impl.handle_ = INVALID_HANDLE_VALUE;
     impl.safe_cancellation_thread_id_ = 0;
   }
+  else
+  {
+    ec = boost::system::error_code();
+  }
 
-  ec = boost::system::error_code();
   return ec;
 }
 
@@ -164,8 +230,12 @@ boost::system::error_code win_iocp_handle_service::cancel(
   if (!is_open(impl))
   {
     ec = boost::asio::error::bad_descriptor;
+    return ec;
   }
-  else if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
+
+  BOOST_ASIO_HANDLER_OPERATION(("handle", &impl, "cancel"));
+
+  if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
         ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
   {
     // The version of Windows supports cancellation from any thread.
@@ -437,6 +507,8 @@ void win_iocp_handle_service::close_for_destruction(implementation_type& impl)
 {
   if (is_open(impl))
   {
+    BOOST_ASIO_HANDLER_OPERATION(("handle", &impl, "close"));
+
     ::CloseHandle(impl.handle_);
     impl.handle_ = INVALID_HANDLE_VALUE;
     impl.safe_cancellation_thread_id_ = 0;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp
index 18b9413..f174dc7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp
@@ -40,7 +40,19 @@ void win_iocp_io_service::dispatch(Handler handler)
     boost_asio_handler_invoke_helpers::invoke(handler, handler);
   }
   else
-    post(handler);
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef completion_handler<Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch"));
+
+    post_immediate_completion(p.p);
+    p.v = p.p = 0;
+  }
 }
 
 template <typename Handler>
@@ -53,6 +65,8 @@ void win_iocp_io_service::post(Handler handler)
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
+  BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "post"));
+
   post_immediate_completion(p.p);
   p.v = p.p = 0;
 }
@@ -93,7 +107,8 @@ void win_iocp_io_service::schedule_timer(timer_queue<Time_Traits>& queue,
 
 template <typename Time_Traits>
 std::size_t win_iocp_io_service::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
 {
   // If the service has been shut down we silently ignore the cancellation.
   if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
@@ -101,7 +116,7 @@ std::size_t win_iocp_io_service::cancel_timer(timer_queue<Time_Traits>& queue,
 
   mutex::scoped_lock lock(dispatch_mutex_);
   op_queue<win_iocp_operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   post_deferred_completions(ops);
   return n;
 }
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp
index 9711702..4607669 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp
@@ -70,6 +70,7 @@ win_iocp_io_service::win_iocp_io_service(boost::asio::io_service& io_service)
     shutdown_(0),
     dispatch_required_(0)
 {
+  BOOST_ASIO_HANDLER_TRACKING_INIT;
 }
 
 void win_iocp_io_service::init(size_t concurrency_hint)
@@ -89,7 +90,7 @@ void win_iocp_io_service::shutdown_service()
 {
   ::InterlockedExchange(&shutdown_, 1);
 
-  if (timer_thread_)
+  if (timer_thread_.get())
   {
     LARGE_INTEGER timeout;
     timeout.QuadPart = 1;
@@ -125,7 +126,7 @@ void win_iocp_io_service::shutdown_service()
     }
   }
 
-  if (timer_thread_)
+  if (timer_thread_.get())
     timer_thread_->join();
 }
 
@@ -262,6 +263,17 @@ void win_iocp_io_service::post_deferred_completions(
   }
 }
 
+void win_iocp_io_service::abandon_operations(
+    op_queue<win_iocp_operation>& ops)
+{
+  while (win_iocp_operation* op = ops.front())
+  {
+    ops.pop();
+    ::InterlockedDecrement(&outstanding_work_);
+    op->destroy();
+  }
+}
+
 void win_iocp_io_service::on_pending(win_iocp_operation* op)
 {
   if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1)
@@ -455,7 +467,7 @@ void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue)
         &timeout, max_timeout_msec, 0, 0, FALSE);
   }
 
-  if (!timer_thread_)
+  if (!timer_thread_.get())
   {
     timer_thread_function thread_function = { this };
     timer_thread_.reset(new thread(thread_function, 65536));
@@ -471,7 +483,7 @@ void win_iocp_io_service::do_remove_timer_queue(timer_queue_base& queue)
 
 void win_iocp_io_service::update_timeout()
 {
-  if (timer_thread_)
+  if (timer_thread_.get())
   {
     // There's no point updating the waitable timer if the new timeout period
     // exceeds the maximum timeout. In that case, we might as well wait for the
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
index 32ab6d1..0c641fc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
@@ -127,7 +127,7 @@ boost::system::error_code win_iocp_serial_port_service::do_set_option(
   ::DCB dcb;
   memset(&dcb, 0, sizeof(DCB));
   dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native(impl), &dcb))
+  if (!::GetCommState(handle_service_.native_handle(impl), &dcb))
   {
     DWORD last_error = ::GetLastError();
     ec = boost::system::error_code(last_error,
@@ -138,7 +138,7 @@ boost::system::error_code win_iocp_serial_port_service::do_set_option(
   if (store(option, dcb, ec))
     return ec;
 
-  if (!::SetCommState(handle_service_.native(impl), &dcb))
+  if (!::SetCommState(handle_service_.native_handle(impl), &dcb))
   {
     DWORD last_error = ::GetLastError();
     ec = boost::system::error_code(last_error,
@@ -160,7 +160,7 @@ boost::system::error_code win_iocp_serial_port_service::do_get_option(
   ::DCB dcb;
   memset(&dcb, 0, sizeof(DCB));
   dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native(impl), &dcb))
+  if (!::GetCommState(handle_service_.native_handle(impl), &dcb))
   {
     DWORD last_error = ::GetLastError();
     ec = boost::system::error_code(last_error,
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
index 0a2825b..2b8d0cb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
@@ -69,6 +69,80 @@ void win_iocp_socket_service_base::construct(
   impl_list_ = &impl;
 }
 
+void win_iocp_socket_service_base::base_move_construct(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    win_iocp_socket_service_base::base_implementation_type& other_impl)
+{
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.cancel_token_ = other_impl.cancel_token_;
+  other_impl.cancel_token_.reset();
+
+#if defined(BOOST_ASIO_ENABLE_CANCELIO)
+  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
+  other_impl.safe_cancellation_thread_id_ = 0;
+#endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
+
+  // Insert implementation into linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void win_iocp_socket_service_base::base_move_assign(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    win_iocp_socket_service_base& other_service,
+    win_iocp_socket_service_base::base_implementation_type& other_impl)
+{
+  close_for_destruction(impl);
+
+  if (this != &other_service)
+  {
+    // Remove implementation from linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.cancel_token_ = other_impl.cancel_token_;
+  other_impl.cancel_token_.reset();
+
+#if defined(BOOST_ASIO_ENABLE_CANCELIO)
+  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
+  other_impl.safe_cancellation_thread_id_ = 0;
+#endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
+
+  if (this != &other_service)
+  {
+    // Insert implementation into linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_);
+    impl.next_ = other_service.impl_list_;
+    impl.prev_ = 0;
+    if (other_service.impl_list_)
+      other_service.impl_list_->prev_ = &impl;
+    other_service.impl_list_ = &impl;
+  }
+}
+
 void win_iocp_socket_service_base::destroy(
     win_iocp_socket_service_base::base_implementation_type& impl)
 {
@@ -92,6 +166,8 @@ boost::system::error_code win_iocp_socket_service_base::close(
 {
   if (is_open(impl))
   {
+    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+
     // Check if the reactor was created, in which case we need to close the
     // socket on the reactor as well to cancel any operations that might be
     // running there.
@@ -99,18 +175,17 @@ boost::system::error_code win_iocp_socket_service_base::close(
           interlocked_compare_exchange_pointer(
             reinterpret_cast<void**>(&reactor_), 0, 0));
     if (r)
-      r->close_descriptor(impl.socket_, impl.reactor_data_);
+      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
   }
 
-  if (socket_ops::close(impl.socket_, impl.state_, false, ec) == 0)
-  {
-    impl.socket_ = invalid_socket;
-    impl.state_ = 0;
-    impl.cancel_token_.reset();
+  socket_ops::close(impl.socket_, impl.state_, false, ec);
+
+  impl.socket_ = invalid_socket;
+  impl.state_ = 0;
+  impl.cancel_token_.reset();
 #if defined(BOOST_ASIO_ENABLE_CANCELIO)
-    impl.safe_cancellation_thread_id_ = 0;
+  impl.safe_cancellation_thread_id_ = 0;
 #endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
-  }
 
   return ec;
 }
@@ -124,7 +199,10 @@ boost::system::error_code win_iocp_socket_service_base::cancel(
     ec = boost::asio::error::bad_descriptor;
     return ec;
   }
-  else if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
+
+  BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "cancel"));
+
+  if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
         ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
   {
     // The version of Windows supports cancellation from any thread.
@@ -474,7 +552,7 @@ void win_iocp_socket_service_base::start_connect_op(
 
   if ((impl.state_ & socket_ops::non_blocking) != 0
       || socket_ops::set_internal_non_blocking(
-        impl.socket_, impl.state_, op->ec_))
+        impl.socket_, impl.state_, true, op->ec_))
   {
     if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
     {
@@ -497,6 +575,8 @@ void win_iocp_socket_service_base::close_for_destruction(
 {
   if (is_open(impl))
   {
+    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+
     // Check if the reactor was created, in which case we need to close the
     // socket on the reactor as well to cancel any operations that might be
     // running there.
@@ -504,7 +584,7 @@ void win_iocp_socket_service_base::close_for_destruction(
           interlocked_compare_exchange_pointer(
             reinterpret_cast<void**>(&reactor_), 0, 0));
     if (r)
-      r->close_descriptor(impl.socket_, impl.reactor_data_);
+      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
   }
 
   boost::system::error_code ignored_ec;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp
new file mode 100644
index 0000000..bf3193a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp
@@ -0,0 +1,120 @@
+//
+// detail/impl/win_static_mutex.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_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
+#define BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_WINDOWS)
+
+#include <cstdio>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/win_static_mutex.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+void win_static_mutex::init()
+{
+  int error = do_init();
+  boost::system::error_code ec(error,
+      boost::asio::error::get_system_category());
+  boost::asio::detail::throw_error(ec, "static_mutex");
+}
+
+int win_static_mutex::do_init()
+{
+  using namespace std; // For sprintf.
+  wchar_t mutex_name[128];
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+  swprintf_s(mutex_name, 128,
+#else // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+  swprintf(mutex_name,
+#endif // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+      L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p",
+      static_cast<unsigned int>(::GetCurrentProcessId()), this);
+
+  HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name);
+  DWORD last_error = ::GetLastError();
+  if (mutex == 0)
+    return ::GetLastError();
+
+  if (last_error == ERROR_ALREADY_EXISTS)
+    ::WaitForSingleObject(mutex, INFINITE);
+
+  if (initialised_)
+  {
+    ::ReleaseMutex(mutex);
+    ::CloseHandle(mutex);
+    return 0;
+  }
+
+#if defined(__MINGW32__)
+  // Not sure if MinGW supports structured exception handling, so for now
+  // we'll just call the Windows API and hope.
+# if defined(UNDER_CE)
+  ::InitializeCriticalSection(&crit_section_);
+# else
+  if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
+  {
+    last_error = ::GetLastError();
+    ::ReleaseMutex(mutex);
+    ::CloseHandle(mutex);
+    return last_error;
+  }
+# endif
+#else
+  __try
+  {
+# if defined(UNDER_CE)
+    ::InitializeCriticalSection(&crit_section_);
+# else
+    if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
+    {
+      last_error = ::GetLastError();
+      ::ReleaseMutex(mutex);
+      ::CloseHandle(mutex);
+      return last_error;
+    }
+# endif
+  }
+  __except(GetExceptionCode() == STATUS_NO_MEMORY
+      ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+  {
+    ::ReleaseMutex(mutex);
+    ::CloseHandle(mutex);
+    return ERROR_OUTOFMEMORY;
+  }
+#endif
+
+  initialised_ = true;
+  ::ReleaseMutex(mutex);
+  ::CloseHandle(mutex);
+  return 0;
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_WINDOWS)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
index 07cc5c2..c9a3fa7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
@@ -102,12 +102,12 @@ void win_thread::start_thread(func_base* arg, unsigned int stack_size)
 
 unsigned int __stdcall win_thread_function(void* arg)
 {
-  std::auto_ptr<win_thread::func_base> func(
-      static_cast<win_thread::func_base*>(arg));
+  win_thread::auto_func_base_ptr func = {
+      static_cast<win_thread::func_base*>(arg) };
 
-  ::SetEvent(func->entry_event_);
+  ::SetEvent(func.ptr->entry_event_);
 
-  func->run();
+  func.ptr->run();
 
   // Signal that the thread has finished its work, but rather than returning go
   // to sleep to put the thread into a well known state. If the thread is being
@@ -115,8 +115,9 @@ unsigned int __stdcall win_thread_function(void* arg)
   // TerminateThread (to avoid a deadlock in DllMain). Otherwise, the SleepEx
   // call will be interrupted using QueueUserAPC and the thread will shut down
   // cleanly.
-  HANDLE exit_event = func->exit_event_;
-  func.reset();
+  HANDLE exit_event = func.ptr->exit_event_;
+  delete func.ptr;
+  func.ptr = 0;
   ::SetEvent(exit_event);
   ::SleepEx(INFINITE, TRUE);
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
index c63e6e5..a68603f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
@@ -46,7 +46,7 @@ public:
   // Get the name of the IO control command.
   int name() const
   {
-    return FIONBIO;
+    return static_cast<int>(FIONBIO);
   }
 
   // Set the value of the I/O control command.
@@ -96,7 +96,7 @@ public:
   // Get the name of the IO control command.
   int name() const
   {
-    return FIONREAD;
+    return static_cast<int>(FIONREAD);
   }
 
   // Set the value of the I/O control command.
diff --git a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
index 80f7ca3..707c2e5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
@@ -20,6 +20,7 @@
 
 #if defined(BOOST_ASIO_HAS_KQUEUE)
 
+#include <boost/limits.hpp>
 #include <cstddef>
 #include <sys/types.h>
 #include <sys/event.h>
@@ -62,6 +63,7 @@ public:
     friend class kqueue_reactor;
     friend class object_pool_access;
     mutex mutex_;
+    int descriptor_;
     op_queue<reactor_op> op_queue_[max_ops];
     bool shutdown_;
     descriptor_state* next_;
@@ -80,6 +82,10 @@ public:
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
+  // Recreate internal descriptors following a fork.
+  BOOST_ASIO_DECL void fork_service(
+      boost::asio::io_service::fork_event fork_ev);
+
   // Initialise the task.
   BOOST_ASIO_DECL void init_task();
 
@@ -88,6 +94,17 @@ public:
   BOOST_ASIO_DECL int register_descriptor(socket_type descriptor,
       per_descriptor_data& descriptor_data);
 
+  // Register a descriptor with an associated single operation. Returns 0 on
+  // success, system error code on failure.
+  BOOST_ASIO_DECL int register_internal_descriptor(
+      int op_type, socket_type descriptor,
+      per_descriptor_data& descriptor_data, reactor_op* op);
+
+  // Move descriptor registration from one descriptor_data object to another.
+  BOOST_ASIO_DECL void move_descriptor(socket_type descriptor,
+      per_descriptor_data& target_descriptor_data,
+      per_descriptor_data& source_descriptor_data);
+
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op)
   {
@@ -108,8 +125,12 @@ public:
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void close_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
+  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
+      per_descriptor_data& descriptor_data, bool closing);
+
+  // Remote the descriptor's registration from the reactor.
+  BOOST_ASIO_DECL void deregister_internal_descriptor(
+      socket_type descriptor, per_descriptor_data& descriptor_data);
 
   // Add a new timer queue to the reactor.
   template <typename Time_Traits>
@@ -130,7 +151,8 @@ public:
   // number of operations that have been posted or dispatched.
   template <typename Time_Traits>
   std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer);
+      typename timer_queue<Time_Traits>::per_timer_data& timer,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
   // Run the kqueue loop.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp
new file mode 100644
index 0000000..4bb8517
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp
@@ -0,0 +1,62 @@
+//
+// detail/null_static_mutex.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_DETAIL_NULL_STATIC_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+
+#include <boost/asio/detail/scoped_lock.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+struct null_static_mutex
+{
+  typedef boost::asio::detail::scoped_lock<null_static_mutex> scoped_lock;
+
+  // Initialise the mutex.
+  void init()
+  {
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+  }
+
+  int unused_;
+};
+
+#define BOOST_ASIO_NULL_STATIC_MUTEX_INIT { 0 }
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+
+#endif // BOOST_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp b/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp
index d385d3e..7199752 100644
--- a/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp
@@ -85,14 +85,6 @@ struct ipv6_mreq_emulation
   unsigned int ipv6mr_interface;
 };
 
-#if !defined(IN6ADDR_ANY_INIT)
-# define IN6ADDR_ANY_INIT { 0 }
-#endif
-
-#if !defined(IN6ADDR_LOOPBACK_INIT)
-# define IN6ADDR_LOOPBACK_INIT { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }
-#endif
-
 struct addrinfo_emulation
 {
   int ai_flags;
@@ -201,122 +193,6 @@ struct addrinfo_emulation
 # define IPV6_LEAVE_GROUP 13
 #endif
 
-inline int IN6_IS_ADDR_UNSPECIFIED(const in6_addr_emulation* a)
-{
-  return ((a->s6_addr[0] == 0)
-      && (a->s6_addr[1] == 0)
-      && (a->s6_addr[2] == 0)
-      && (a->s6_addr[3] == 0)
-      && (a->s6_addr[4] == 0)
-      && (a->s6_addr[5] == 0)
-      && (a->s6_addr[6] == 0)
-      && (a->s6_addr[7] == 0)
-      && (a->s6_addr[8] == 0)
-      && (a->s6_addr[9] == 0)
-      && (a->s6_addr[10] == 0)
-      && (a->s6_addr[11] == 0)
-      && (a->s6_addr[12] == 0)
-      && (a->s6_addr[13] == 0)
-      && (a->s6_addr[14] == 0)
-      && (a->s6_addr[15] == 0));
-}
-
-inline int IN6_IS_ADDR_LOOPBACK(const in6_addr_emulation* a)
-{
-  return ((a->s6_addr[0] == 0)
-      && (a->s6_addr[1] == 0)
-      && (a->s6_addr[2] == 0)
-      && (a->s6_addr[3] == 0)
-      && (a->s6_addr[4] == 0)
-      && (a->s6_addr[5] == 0)
-      && (a->s6_addr[6] == 0)
-      && (a->s6_addr[7] == 0)
-      && (a->s6_addr[8] == 0)
-      && (a->s6_addr[9] == 0)
-      && (a->s6_addr[10] == 0)
-      && (a->s6_addr[11] == 0)
-      && (a->s6_addr[12] == 0)
-      && (a->s6_addr[13] == 0)
-      && (a->s6_addr[14] == 0)
-      && (a->s6_addr[15] == 1));
-}
-
-inline int IN6_IS_ADDR_MULTICAST(const in6_addr_emulation* a)
-{
-  return (a->s6_addr[0] == 0xff);
-}
-
-inline int IN6_IS_ADDR_LINKLOCAL(const in6_addr_emulation* a)
-{
-  return ((a->s6_addr[0] == 0xfe) && ((a->s6_addr[1] & 0xc0) == 0x80));
-}
-
-inline int IN6_IS_ADDR_SITELOCAL(const in6_addr_emulation* a)
-{
-  return ((a->s6_addr[0] == 0xfe) && ((a->s6_addr[1] & 0xc0) == 0xc0));
-}
-
-inline int IN6_IS_ADDR_V4MAPPED(const in6_addr_emulation* a)
-{
-  return ((a->s6_addr[0] == 0)
-      && (a->s6_addr[1] == 0)
-      && (a->s6_addr[2] == 0)
-      && (a->s6_addr[3] == 0)
-      && (a->s6_addr[4] == 0)
-      && (a->s6_addr[5] == 0)
-      && (a->s6_addr[6] == 0)
-      && (a->s6_addr[7] == 0)
-      && (a->s6_addr[8] == 0)
-      && (a->s6_addr[9] == 0)
-      && (a->s6_addr[10] == 0xff)
-      && (a->s6_addr[11] == 0xff));
-}
-
-inline int IN6_IS_ADDR_V4COMPAT(const in6_addr_emulation* a)
-{
-  return ((a->s6_addr[0] == 0)
-      && (a->s6_addr[1] == 0)
-      && (a->s6_addr[2] == 0)
-      && (a->s6_addr[3] == 0)
-      && (a->s6_addr[4] == 0)
-      && (a->s6_addr[5] == 0)
-      && (a->s6_addr[6] == 0)
-      && (a->s6_addr[7] == 0)
-      && (a->s6_addr[8] == 0)
-      && (a->s6_addr[9] == 0)
-      && (a->s6_addr[10] == 0xff)
-      && (a->s6_addr[11] == 0xff)
-      && !((a->s6_addr[12] == 0)
-        && (a->s6_addr[13] == 0)
-        && (a->s6_addr[14] == 0)
-        && ((a->s6_addr[15] == 0) || (a->s6_addr[15] == 1))));
-}
-
-inline int IN6_IS_ADDR_MC_NODELOCAL(const in6_addr_emulation* a)
-{
-  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 1);
-}
-
-inline int IN6_IS_ADDR_MC_LINKLOCAL(const in6_addr_emulation* a)
-{
-  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 2);
-}
-
-inline int IN6_IS_ADDR_MC_SITELOCAL(const in6_addr_emulation* a)
-{
-  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 5);
-}
-
-inline int IN6_IS_ADDR_MC_ORGLOCAL(const in6_addr_emulation* a)
-{
-  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 8);
-}
-
-inline int IN6_IS_ADDR_MC_GLOBAL(const in6_addr_emulation* a)
-{
-  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 0xe);
-}
-
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
index ad32736..5632124 100644
--- a/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
@@ -37,6 +37,9 @@ public:
   // Destructor.
   BOOST_ASIO_DECL ~pipe_select_interrupter();
 
+  // Recreate the interrupter's descriptors. Used after a fork.
+  BOOST_ASIO_DECL void recreate();
+
   // Interrupt the select call.
   BOOST_ASIO_DECL void interrupt();
 
@@ -50,6 +53,12 @@ public:
   }
 
 private:
+  // Open the descriptors. Throws on error.
+  BOOST_ASIO_DECL void open_descriptors();
+
+  // Close the descriptors.
+  BOOST_ASIO_DECL void close_descriptors();
+
   // The read end of a connection used to interrupt the select call. This file
   // descriptor is passed to select such that when it is time to stop, a single
   // byte will be written on the other end of the connection and this
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp
new file mode 100644
index 0000000..0ec16a1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp
@@ -0,0 +1,66 @@
+//
+// detail/posix_static_mutex.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_DETAIL_POSIX_STATIC_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+
+#include <pthread.h>
+#include <boost/asio/detail/scoped_lock.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+struct posix_static_mutex
+{
+  typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
+
+  // Initialise the mutex.
+  void init()
+  {
+    // Nothing to do.
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+    (void)::pthread_mutex_lock(&mutex_); // Ignore EINVAL.
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+    (void)::pthread_mutex_unlock(&mutex_); // Ignore EINVAL.
+  }
+
+  ::pthread_mutex_t mutex_;
+};
+
+#define BOOST_ASIO_POSIX_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER }
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+
+#endif // BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
index 5d8b684..f53c319 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
@@ -39,7 +39,7 @@ class posix_thread
 public:
   // Constructor.
   template <typename Function>
-  posix_thread(Function f)
+  posix_thread(Function f, unsigned int = 0)
     : joined_(false)
   {
     start_thread(new func<Function>(f));
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
index 510c505..551ecaa 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
@@ -42,7 +42,7 @@ class reactive_descriptor_service
 {
 public:
   // The native type of a descriptor.
-  typedef int native_type;
+  typedef int native_handle_type;
 
   // The implementation type of the descriptor.
   class implementation_type
@@ -80,12 +80,22 @@ public:
   // Construct a new descriptor implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
+  // Move-construct a new descriptor implementation.
+  BOOST_ASIO_DECL void move_construct(implementation_type& impl,
+      implementation_type& other_impl);
+
+  // Move-assign from another descriptor implementation.
+  BOOST_ASIO_DECL void move_assign(implementation_type& impl,
+      reactive_descriptor_service& other_service,
+      implementation_type& other_impl);
+
   // Destroy a descriptor implementation.
   BOOST_ASIO_DECL void destroy(implementation_type& impl);
 
   // Assign a native descriptor to a descriptor implementation.
   BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_descriptor, boost::system::error_code& ec);
+      const native_handle_type& native_descriptor,
+      boost::system::error_code& ec);
 
   // Determine whether the descriptor is open.
   bool is_open(const implementation_type& impl) const
@@ -98,11 +108,14 @@ public:
       boost::system::error_code& ec);
 
   // Get the native descriptor representation.
-  native_type native(const implementation_type& impl) const
+  native_handle_type native_handle(const implementation_type& impl) const
   {
     return impl.descriptor_;
   }
 
+  // Release ownership of the native descriptor representation.
+  BOOST_ASIO_DECL native_handle_type release(implementation_type& impl);
+
   // Cancel all operations associated with the descriptor.
   BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec);
@@ -117,6 +130,36 @@ public:
     return ec;
   }
 
+  // Gets the non-blocking mode of the descriptor.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the descriptor.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    descriptor_ops::set_user_non_blocking(
+        impl.descriptor_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the native descriptor implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the native descriptor implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    descriptor_ops::set_internal_non_blocking(
+        impl.descriptor_, impl.state_, mode, ec);
+    return ec;
+  }
+
   // Write some data to the descriptor.
   template <typename ConstBufferSequence>
   size_t write_some(implementation_type& impl,
@@ -152,6 +195,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.descriptor_, buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_write_some"));
+
     start_op(impl, reactor::write_op, p.p, true,
         buffer_sequence_adapter<boost::asio::const_buffer,
           ConstBufferSequence>::all_empty(buffers));
@@ -170,6 +215,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor",
+          &impl, "async_write_some(null_buffers)"));
+
     start_op(impl, reactor::write_op, p.p, false, false);
     p.v = p.p = 0;
   }
@@ -209,6 +257,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.descriptor_, buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_read_some"));
+
     start_op(impl, reactor::read_op, p.p, true,
         buffer_sequence_adapter<boost::asio::mutable_buffer,
           MutableBufferSequence>::all_empty(buffers));
@@ -227,6 +277,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor",
+          &impl, "async_read_some(null_buffers)"));
+
     start_op(impl, reactor::read_op, p.p, false, false);
     p.v = p.p = 0;
   }
@@ -234,7 +287,7 @@ public:
 private:
   // Start the asynchronous operation.
   BOOST_ASIO_DECL void start_op(implementation_type& impl, int op_type,
-      reactor_op* op, bool non_blocking, bool noop);
+      reactor_op* op, bool is_non_blocking, bool noop);
 
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp
index 6ccc19e..cf939b2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp
@@ -34,10 +34,10 @@ class reactive_null_buffers_op : public reactor_op
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_null_buffers_op);
 
-  reactive_null_buffers_op(Handler handler)
+  reactive_null_buffers_op(Handler& handler)
     : reactor_op(&reactive_null_buffers_op::do_perform,
         &reactive_null_buffers_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -53,6 +53,8 @@ public:
     reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -68,7 +70,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp
index 303c1f0..9d75062 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp
@@ -39,7 +39,7 @@ class reactive_serial_port_service
 {
 public:
   // The native type of a serial port.
-  typedef reactive_descriptor_service::native_type native_type;
+  typedef reactive_descriptor_service::native_handle_type native_handle_type;
 
   // The implementation type of the serial port.
   typedef reactive_descriptor_service::implementation_type implementation_type;
@@ -56,6 +56,22 @@ public:
     descriptor_service_.construct(impl);
   }
 
+  // Move-construct a new serial port implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    descriptor_service_.move_construct(impl, other_impl);
+  }
+
+  // Move-assign from another serial port implementation.
+  void move_assign(implementation_type& impl,
+      reactive_serial_port_service& other_service,
+      implementation_type& other_impl)
+  {
+    descriptor_service_.move_assign(impl,
+        other_service.descriptor_service_, other_impl);
+  }
+
   // Destroy a serial port implementation.
   void destroy(implementation_type& impl)
   {
@@ -68,7 +84,8 @@ public:
 
   // Assign a native descriptor to a serial port implementation.
   boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_descriptor, boost::system::error_code& ec)
+      const native_handle_type& native_descriptor,
+      boost::system::error_code& ec)
   {
     return descriptor_service_.assign(impl, native_descriptor, ec);
   }
@@ -87,9 +104,9 @@ public:
   }
 
   // Get the native serial port representation.
-  native_type native(implementation_type& impl)
+  native_handle_type native_handle(implementation_type& impl)
   {
-    return descriptor_service_.native(impl);
+    return descriptor_service_.native_handle(impl);
   }
 
   // Cancel all operations associated with the serial port.
@@ -125,7 +142,7 @@ public:
   {
     errno = 0;
     descriptor_ops::error_wrapper(::tcsendbreak(
-          descriptor_service_.native(impl), 0), ec);
+          descriptor_service_.native_handle(impl), 0), ec);
     return ec;
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp
index 3805c9f..3957f3a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp
@@ -87,10 +87,10 @@ public:
 
   reactive_socket_accept_op(socket_type socket,
       socket_ops::state_type state, Socket& peer, const Protocol& protocol,
-      typename Protocol::endpoint* peer_endpoint, Handler handler)
+      typename Protocol::endpoint* peer_endpoint, Handler& handler)
     : reactive_socket_accept_op_base<Socket, Protocol>(socket, state, peer,
         protocol, peer_endpoint, &reactive_socket_accept_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -101,6 +101,8 @@ public:
     reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -116,7 +118,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp
index 6de7474..66dddad 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp
@@ -56,10 +56,10 @@ class reactive_socket_connect_op : public reactive_socket_connect_op_base
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_connect_op);
 
-  reactive_socket_connect_op(socket_type socket, Handler handler)
+  reactive_socket_connect_op(socket_type socket, Handler& handler)
     : reactive_socket_connect_op_base(socket,
         &reactive_socket_connect_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -71,6 +71,8 @@ public:
       (static_cast<reactive_socket_connect_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -86,7 +88,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp
index 75ce44f..255b0ee 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp
@@ -54,7 +54,7 @@ public:
 
     return socket_ops::non_blocking_recv(o->socket_,
         bufs.buffers(), bufs.count(), o->flags_,
-        (o->state_ & socket_ops::stream_oriented),
+        (o->state_ & socket_ops::stream_oriented) != 0,
         o->ec_, o->bytes_transferred_);
   }
 
@@ -74,10 +74,10 @@ public:
 
   reactive_socket_recv_op(socket_type socket,
       socket_ops::state_type state, const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
     : reactive_socket_recv_op_base<MutableBufferSequence>(socket, state,
         buffers, flags, &reactive_socket_recv_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -88,6 +88,8 @@ public:
     reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -103,7 +105,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp
index b496ea0..601bcc4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp
@@ -82,11 +82,11 @@ public:
 
   reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
       const MutableBufferSequence& buffers, Endpoint& endpoint,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
     : reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
         socket, protocol_type, buffers, endpoint, flags,
         &reactive_socket_recvfrom_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -98,6 +98,8 @@ public:
         static_cast<reactive_socket_recvfrom_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -113,7 +115,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp
new file mode 100644
index 0000000..56de631
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp
@@ -0,0 +1,126 @@
+//
+// detail/reactive_socket_recvmsg_op.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_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
+#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_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/utility/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/reactor_op.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/socket_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence>
+class reactive_socket_recvmsg_op_base : public reactor_op
+{
+public:
+  reactive_socket_recvmsg_op_base(socket_type socket,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, func_type complete_func)
+    : reactor_op(&reactive_socket_recvmsg_op_base::do_perform, complete_func),
+      socket_(socket),
+      buffers_(buffers),
+      in_flags_(in_flags),
+      out_flags_(out_flags)
+  {
+  }
+
+  static bool do_perform(reactor_op* base)
+  {
+    reactive_socket_recvmsg_op_base* o(
+        static_cast<reactive_socket_recvmsg_op_base*>(base));
+
+    buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs(o->buffers_);
+
+    return socket_ops::non_blocking_recvmsg(o->socket_,
+        bufs.buffers(), bufs.count(),
+        o->in_flags_, o->out_flags_,
+        o->ec_, o->bytes_transferred_);
+  }
+
+private:
+  socket_type socket_;
+  MutableBufferSequence buffers_;
+  socket_base::message_flags in_flags_;
+  socket_base::message_flags& out_flags_;
+};
+
+template <typename MutableBufferSequence, typename Handler>
+class reactive_socket_recvmsg_op :
+  public reactive_socket_recvmsg_op_base<MutableBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_recvmsg_op);
+
+  reactive_socket_recvmsg_op(socket_type socket,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, Handler& handler)
+    : reactive_socket_recvmsg_op_base<MutableBufferSequence>(socket, buffers,
+        in_flags, out_flags, &reactive_socket_recvmsg_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      boost::system::error_code /*ec*/, std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    reactive_socket_recvmsg_op* o(
+        static_cast<reactive_socket_recvmsg_op*>(base));
+    ptr p = { boost::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp
index 2fe195e..691a220 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp
@@ -71,10 +71,10 @@ public:
 
   reactive_socket_send_op(socket_type socket,
       const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
     : reactive_socket_send_op_base<ConstBufferSequence>(socket,
         buffers, flags, &reactive_socket_send_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -85,6 +85,8 @@ public:
     reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -100,7 +102,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp
index 12046c3..712d4b7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp
@@ -74,10 +74,10 @@ public:
 
   reactive_socket_sendto_op(socket_type socket,
       const ConstBufferSequence& buffers, const Endpoint& endpoint,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
     : reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>(socket,
         buffers, endpoint, flags, &reactive_socket_sendto_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -88,6 +88,8 @@ public:
     reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -103,7 +105,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
index 92eef4a..76e9cbf 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
@@ -56,7 +56,7 @@ public:
   typedef typename Protocol::endpoint endpoint_type;
 
   // The native type of a socket.
-  typedef socket_type native_type;
+  typedef socket_type native_handle_type;
 
   // The implementation type of the socket.
   struct implementation_type :
@@ -78,6 +78,27 @@ public:
   {
   }
 
+  // Move-construct a new socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+  }
+
+  // Move-assign from another socket implementation.
+  void move_assign(implementation_type& impl,
+      reactive_socket_service_base& other_service,
+      implementation_type& other_impl)
+  {
+    this->base_move_assign(impl, other_service, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+  }
+
   // Open a new socket implementation.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
@@ -90,7 +111,7 @@ public:
 
   // Assign a native socket to a socket implementation.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_type& native_socket,
+      const protocol_type& protocol, const native_handle_type& native_socket,
       boost::system::error_code& ec)
   {
     if (!do_assign(impl, protocol.type(), native_socket, ec))
@@ -99,7 +120,7 @@ public:
   }
 
   // Get the native socket representation.
-  native_type native(implementation_type& impl)
+  native_handle_type native_handle(implementation_type& impl)
   {
     return impl.socket_;
   }
@@ -204,6 +225,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to"));
+
     start_op(impl, reactor::write_op, p.p, true, false);
     p.v = p.p = 0;
   }
@@ -220,6 +243,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_send_to(null_buffers)"));
+
     start_op(impl, reactor::write_op, p.p, false, false);
     p.v = p.p = 0;
   }
@@ -274,10 +300,13 @@ public:
     typename op::ptr p = { boost::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
-    int protocol_type = impl.protocol_.type();
-    p.p = new (p.v) op(impl.socket_, protocol_type,
+    int protocol = impl.protocol_.type();
+    p.p = new (p.v) op(impl.socket_, protocol,
         buffers, sender_endpoint, flags, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_receive_from"));
+
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
@@ -298,6 +327,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_receive_from(null_buffers)"));
+
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
 
@@ -351,6 +383,8 @@ public:
     p.p = new (p.v) op(impl.socket_, impl.state_, peer,
         impl.protocol_, peer_endpoint, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_accept"));
+
     start_accept_op(impl, p.p, peer.is_open());
     p.v = p.p = 0;
   }
@@ -376,6 +410,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
+
     start_connect_op(impl, p.p, peer_endpoint.data(), peer_endpoint.size());
     p.v = p.p = 0;
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp
index df87ddb..52aa4e3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp
@@ -27,6 +27,7 @@
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/reactive_null_buffers_op.hpp>
 #include <boost/asio/detail/reactive_socket_recv_op.hpp>
+#include <boost/asio/detail/reactive_socket_recvmsg_op.hpp>
 #include <boost/asio/detail/reactive_socket_send_op.hpp>
 #include <boost/asio/detail/reactor.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
@@ -44,7 +45,7 @@ class reactive_socket_service_base
 {
 public:
   // The native type of a socket.
-  typedef socket_type native_type;
+  typedef socket_type native_handle_type;
 
   // The implementation type of the socket.
   struct base_implementation_type
@@ -69,6 +70,15 @@ public:
   // Construct a new socket implementation.
   BOOST_ASIO_DECL void construct(base_implementation_type& impl);
 
+  // Move-construct a new socket implementation.
+  BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl,
+      base_implementation_type& other_impl);
+
+  // Move-assign from another socket implementation.
+  BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl,
+      reactive_socket_service_base& other_service,
+      base_implementation_type& other_impl);
+
   // Destroy a socket implementation.
   BOOST_ASIO_DECL void destroy(base_implementation_type& impl);
 
@@ -83,7 +93,7 @@ public:
       base_implementation_type& impl, boost::system::error_code& ec);
 
   // Get the native socket representation.
-  native_type native(base_implementation_type& impl)
+  native_handle_type native_handle(base_implementation_type& impl)
   {
     return impl.socket_;
   }
@@ -124,7 +134,35 @@ public:
     return ec;
   }
 
-  /// Disable sends or receives on the socket.
+  // Gets the non-blocking mode of the socket.
+  bool non_blocking(const base_implementation_type& impl) const
+  {
+    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(base_implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const base_implementation_type& impl) const
+  {
+    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(base_implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Disable sends or receives on the socket.
   boost::system::error_code shutdown(base_implementation_type& impl,
       socket_base::shutdown_type what, boost::system::error_code& ec)
   {
@@ -169,6 +207,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, buffers, flags, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
+
     start_op(impl, reactor::write_op, p.p, true,
         ((impl.state_ & socket_ops::stream_oriented)
           && buffer_sequence_adapter<boost::asio::const_buffer,
@@ -188,6 +228,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_send(null_buffers)"));
+
     start_op(impl, reactor::write_op, p.p, false, false);
     p.v = p.p = 0;
   }
@@ -229,6 +272,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
+
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
@@ -251,6 +296,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_receive(null_buffers)"));
+
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
@@ -258,6 +306,87 @@ public:
     p.v = p.p = 0;
   }
 
+  // Receive some data with associated flags. Returns the number of bytes
+  // received.
+  template <typename MutableBufferSequence>
+  size_t receive_with_flags(base_implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs(buffers);
+
+    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
+        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
+  }
+
+  // Wait until data can be received without blocking.
+  size_t receive_with_flags(base_implementation_type& impl,
+      const null_buffers&, socket_base::message_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    // Wait for socket to become ready.
+    socket_ops::poll_read(impl.socket_, ec);
+
+    // Clear out_flags, since we cannot give it any other sensible value when
+    // performing a null_buffers operation.
+    out_flags = 0;
+
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence, typename Handler>
+  void async_receive_with_flags(base_implementation_type& impl,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef reactive_socket_recvmsg_op<MutableBufferSequence, Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(impl.socket_, buffers, in_flags, out_flags, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_receive_with_flags"));
+
+    start_op(impl,
+        (in_flags & socket_base::message_out_of_band)
+          ? reactor::except_op : reactor::read_op,
+        p.p, (in_flags & socket_base::message_out_of_band) == 0, false);
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler>
+  void async_receive_with_flags(base_implementation_type& impl,
+      const null_buffers&, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef reactive_null_buffers_op<Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl,
+          "async_receive_with_flags(null_buffers)"));
+
+    // Clear out_flags, since we cannot give it any other sensible value when
+    // performing a null_buffers operation.
+    out_flags = 0;
+
+    start_op(impl,
+        (in_flags & socket_base::message_out_of_band)
+          ? reactor::except_op : reactor::read_op,
+        p.p, false, false);
+    p.v = p.p = 0;
+  }
+
 protected:
   // Open a new socket implementation.
   BOOST_ASIO_DECL boost::system::error_code do_open(
@@ -267,11 +396,11 @@ protected:
   // Assign a native socket to a socket implementation.
   BOOST_ASIO_DECL boost::system::error_code do_assign(
       base_implementation_type& impl, int type,
-      const native_type& native_socket, boost::system::error_code& ec);
+      const native_handle_type& native_socket, boost::system::error_code& ec);
 
   // Start the asynchronous read or write operation.
   BOOST_ASIO_DECL void start_op(base_implementation_type& impl, int op_type,
-      reactor_op* op, bool non_blocking, bool noop);
+      reactor_op* op, bool is_non_blocking, bool noop);
 
   // Start the asynchronous accept operation.
   BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl,
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp b/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
index 46acda3..102c62c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
@@ -43,12 +43,12 @@ public:
   typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
 
   resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
-      const endpoint_type& endpoint, io_service_impl& ios, Handler handler)
+      const endpoint_type& endpoint, io_service_impl& ios, Handler& handler)
     : operation(&resolve_endpoint_op::do_complete),
       cancel_token_(cancel_token),
       endpoint_(endpoint),
       io_service_impl_(ios),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -81,6 +81,8 @@ public:
       // The operation has been returned to the main io_service. The completion
       // handler is ready to be delivered.
 
+      BOOST_ASIO_HANDLER_COMPLETION((o));
+
       // Make a copy of the handler so that the memory can be deallocated
       // before the upcall is made. Even if we're not about to make an upcall,
       // a sub-object of the handler may be the true owner of the memory
@@ -95,7 +97,9 @@ public:
       if (owner)
       {
         boost::asio::detail::fenced_block b;
+        BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
         boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+        BOOST_ASIO_HANDLER_INVOCATION_END;
       }
     }
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
index 379ec39..7eb70b8 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
@@ -44,12 +44,12 @@ public:
   typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
 
   resolve_op(socket_ops::weak_cancel_token_type cancel_token,
-      const query_type& query, io_service_impl& ios, Handler handler)
+      const query_type& query, io_service_impl& ios, Handler& handler)
     : operation(&resolve_op::do_complete),
       cancel_token_(cancel_token),
       query_(query),
       io_service_impl_(ios),
-      handler_(handler),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
       addrinfo_(0)
   {
   }
@@ -86,6 +86,8 @@ public:
       // The operation has been returned to the main io_service. The completion
       // handler is ready to be delivered.
 
+      BOOST_ASIO_HANDLER_COMPLETION((o));
+
       // Make a copy of the handler so that the memory can be deallocated
       // before the upcall is made. Even if we're not about to make an upcall,
       // a sub-object of the handler may be the true owner of the memory
@@ -105,7 +107,9 @@ public:
       if (owner)
       {
         boost::asio::detail::fenced_block b;
+        BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
         boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+        BOOST_ASIO_HANDLER_INVOCATION_END;
       }
     }
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
index 1c343cb..c5ff8f6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
@@ -67,8 +67,8 @@ public:
 
   // Asynchronously resolve a query to a list of entries.
   template <typename Handler>
-  void async_resolve(implementation_type& impl, const query_type& query,
-      Handler handler)
+  void async_resolve(implementation_type& impl,
+      const query_type& query, Handler handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef resolve_op<Protocol, Handler> op;
@@ -77,6 +77,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl, query, io_service_impl_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+
     start_resolve_op(p.p);
     p.v = p.p = 0;
   }
@@ -97,8 +99,8 @@ public:
 
   // Asynchronously resolve an endpoint to a list of entries.
   template <typename Handler>
-  void async_resolve(implementation_type& impl, const endpoint_type& endpoint,
-      Handler handler)
+  void async_resolve(implementation_type& impl,
+      const endpoint_type& endpoint, Handler handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef resolve_endpoint_op<Protocol, Handler> op;
@@ -107,6 +109,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl, endpoint, io_service_impl_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+
     start_resolve_op(p.p);
     p.v = p.p = 0;
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
index 60e9e09..73a8efa 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
@@ -16,7 +16,6 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/scoped_ptr.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/mutex.hpp>
@@ -24,6 +23,7 @@
 #include <boost/asio/detail/operation.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/scoped_ptr.hpp>
 #include <boost/asio/detail/thread.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -48,6 +48,10 @@ public:
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
+  // Perform any fork-related housekeeping.
+  BOOST_ASIO_DECL void fork_service(
+      boost::asio::io_service::fork_event fork_ev);
+
   // Construct a new resolver implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
@@ -100,16 +104,16 @@ private:
   boost::asio::detail::mutex mutex_;
 
   // Private io_service used for performing asynchronous host resolution.
-  boost::scoped_ptr<boost::asio::io_service> work_io_service_;
+  boost::asio::detail::scoped_ptr<boost::asio::io_service> work_io_service_;
 
   // The work io_service implementation used to post completions.
   io_service_impl& work_io_service_impl_;
 
   // Work for the private io_service to perform.
-  boost::scoped_ptr<boost::asio::io_service::work> work_;
+  boost::asio::detail::scoped_ptr<boost::asio::io_service::work> work_;
 
   // Thread used for running the work io_service's run loop.
-  boost::scoped_ptr<boost::asio::detail::thread> work_thread_;
+  boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
 };
 
 } // namespace detail
diff --git a/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp
new file mode 100644
index 0000000..23a1007
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp
@@ -0,0 +1,81 @@
+//
+// detail/scoped_ptr.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_DETAIL_SCOPED_PTR_HPP
+#define BOOST_ASIO_DETAIL_SCOPED_PTR_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/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename T>
+class scoped_ptr
+{
+public:
+  // Constructor.
+  explicit scoped_ptr(T* p = 0)
+    : p_(p)
+  {
+  }
+
+  // Destructor.
+  ~scoped_ptr()
+  {
+    delete p_;
+  }
+
+  // Access.
+  T* get()
+  {
+    return p_;
+  }
+
+  // Access.
+  T* operator->()
+  {
+    return p_;
+  }
+
+  // Dereference.
+  T& operator*()
+  {
+    return *p_;
+  }
+
+  // Reset pointer.
+  void reset(T* p = 0)
+  {
+    delete p_;
+    p_ = p;
+  }
+
+private:
+  // Disallow copying and assignment.
+  scoped_ptr(const scoped_ptr&);
+  scoped_ptr& operator=(const scoped_ptr&);
+
+  T* p_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SCOPED_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
index f4f8bdf..6cefe50 100644
--- a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
@@ -22,6 +22,7 @@
       && !defined(BOOST_ASIO_HAS_EPOLL) \
       && !defined(BOOST_ASIO_HAS_KQUEUE))
 
+#include <boost/limits.hpp>
 #include <cstddef>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
@@ -72,6 +73,10 @@ public:
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
+  // Recreate internal descriptors following a fork.
+  BOOST_ASIO_DECL void fork_service(
+      boost::asio::io_service::fork_event fork_ev);
+
   // Initialise the task, but only if the reactor is not in its own thread.
   BOOST_ASIO_DECL void init_task();
 
@@ -79,6 +84,12 @@ public:
   // code on failure.
   BOOST_ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
 
+  // Register a descriptor with an associated single operation. Returns 0 on
+  // success, system error code on failure.
+  BOOST_ASIO_DECL int register_internal_descriptor(
+      int op_type, socket_type descriptor,
+      per_descriptor_data& descriptor_data, reactor_op* op);
+
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op)
   {
@@ -97,8 +108,17 @@ public:
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void close_descriptor(socket_type descriptor,
-      per_descriptor_data&);
+  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
+      per_descriptor_data&, bool closing);
+
+  // Remote the descriptor's registration from the reactor.
+  BOOST_ASIO_DECL void deregister_internal_descriptor(
+      socket_type descriptor, per_descriptor_data& descriptor_data);
+
+  // Move descriptor registration from one descriptor_data object to another.
+  BOOST_ASIO_DECL void move_descriptor(socket_type descriptor,
+      per_descriptor_data& target_descriptor_data,
+      per_descriptor_data& source_descriptor_data);
 
   // Add a new timer queue to the reactor.
   template <typename Time_Traits>
@@ -119,7 +139,8 @@ public:
   // number of operations that have been posted or dispatched.
   template <typename Time_Traits>
   std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer);
+      typename timer_queue<Time_Traits>::per_timer_data& timer,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
   // Run select once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
diff --git a/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp b/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
index a247ea8..ab97fdb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
@@ -58,6 +58,9 @@ public:
   // Destructor.
   BOOST_ASIO_DECL ~service_registry();
 
+  // Notify all services of a fork event.
+  BOOST_ASIO_DECL void notify_fork(boost::asio::io_service::fork_event fork_ev);
+
   // Get the service object corresponding to the specified service type. Will
   // create a new service object automatically if no such object already
   // exists. Ownership of the service object is not transferred to the caller.
diff --git a/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
index fe497b7..8f181d8 100644
--- a/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
@@ -17,21 +17,21 @@
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1600)
+#if defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 # include <memory>
-#else
+#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 # include <boost/shared_ptr.hpp>
-#endif
+#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1600)
+#if defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 using std::shared_ptr;
-#else
+#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 using boost::shared_ptr;
-#endif
+#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 
 } // namespace detail
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp
new file mode 100644
index 0000000..31480a1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp
@@ -0,0 +1,82 @@
+//
+// detail/signal_handler.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_DETAIL_SIGNAL_HANDLER_HPP
+#define BOOST_ASIO_DETAIL_SIGNAL_HANDLER_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/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/signal_op.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler>
+class signal_handler : public signal_op
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(signal_handler);
+
+  signal_handler(Handler& h)
+    : signal_op(&signal_handler::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      boost::system::error_code /*ec*/, std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    signal_handler* h(static_cast<signal_handler*>(base));
+    ptr p = { boost::addressof(h->handler_), h, h };
+
+    BOOST_ASIO_HANDLER_COMPLETION((h));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, int>
+      handler(h->handler_, h->ec_, h->signal_number_);
+    p.h = boost::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp
new file mode 100644
index 0000000..f7b4978
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp
@@ -0,0 +1,51 @@
+//
+// detail/signal_op.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_DETAIL_SIGNAL_OP_HPP
+#define BOOST_ASIO_DETAIL_SIGNAL_OP_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/operation.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class signal_op
+  : public operation
+{
+public:
+  // The error code to be passed to the completion handler.
+  boost::system::error_code ec_;
+
+  // The signal number to be passed to the completion handler.
+  int signal_number_;
+
+protected:
+  signal_op(func_type func)
+    : operation(func),
+      signal_number_(0)
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SIGNAL_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp
new file mode 100644
index 0000000..d91650f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp
@@ -0,0 +1,213 @@
+//
+// detail/signal_set_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_DETAIL_SIGNAL_SET_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_SIGNAL_SET_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 <csignal>
+#include <cstddef>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/detail/signal_handler.hpp>
+#include <boost/asio/detail/signal_op.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+# include <boost/asio/detail/reactor.hpp>
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(NSIG) && (NSIG > 0)
+enum { max_signal_number = NSIG };
+#else
+enum { max_signal_number = 128 };
+#endif
+
+extern BOOST_ASIO_DECL struct signal_state* get_signal_state();
+
+extern "C" BOOST_ASIO_DECL void asio_signal_handler(int signal_number);
+
+class signal_set_service
+{
+public:
+  // Type used for tracking an individual signal registration.
+  class registration
+  {
+  public:
+    // Default constructor.
+    registration()
+      : signal_number_(0),
+        queue_(0),
+        undelivered_(0),
+        next_in_table_(0),
+        prev_in_table_(0),
+        next_in_set_(0)
+    {
+    }
+
+  private:
+    // Only this service will have access to the internal values.
+    friend class signal_set_service;
+
+    // The signal number that is registered.
+    int signal_number_;
+
+    // The waiting signal handlers.
+    op_queue<signal_op>* queue_;
+
+    // The number of undelivered signals.
+    std::size_t undelivered_;
+
+    // Pointers to adjacent registrations in the registrations_ table.
+    registration* next_in_table_;
+    registration* prev_in_table_;
+
+    // Link to next registration in the signal set.
+    registration* next_in_set_;
+  };
+
+  // The implementation type of the signal_set.
+  class implementation_type
+  {
+  public:
+    // Default constructor.
+    implementation_type()
+      : signals_(0)
+    {
+    }
+
+  private:
+    // Only this service will have access to the internal values.
+    friend class signal_set_service;
+
+    // The pending signal handlers.
+    op_queue<signal_op> queue_;
+
+    // Linked list of registered signals.
+    registration* signals_;
+  };
+
+  // Constructor.
+  BOOST_ASIO_DECL signal_set_service(boost::asio::io_service& io_service);
+
+  // Destructor.
+  BOOST_ASIO_DECL ~signal_set_service();
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown_service();
+
+  // Perform fork-related housekeeping.
+  BOOST_ASIO_DECL void fork_service(
+      boost::asio::io_service::fork_event fork_ev);
+
+  // Construct a new signal_set implementation.
+  BOOST_ASIO_DECL void construct(implementation_type& impl);
+
+  // Destroy a signal_set implementation.
+  BOOST_ASIO_DECL void destroy(implementation_type& impl);
+
+  // Add a signal to a signal_set.
+  BOOST_ASIO_DECL boost::system::error_code add(implementation_type& impl,
+      int signal_number, boost::system::error_code& ec);
+
+  // Remove a signal to a signal_set.
+  BOOST_ASIO_DECL boost::system::error_code remove(implementation_type& impl,
+      int signal_number, boost::system::error_code& ec);
+
+  // Remove all signals from a signal_set.
+  BOOST_ASIO_DECL boost::system::error_code clear(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Cancel all operations associated with the signal set.
+  BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Start an asynchronous operation to wait for a signal to be delivered.
+  template <typename Handler>
+  void async_wait(implementation_type& impl, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef signal_handler<Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "signal_set", &impl, "async_wait"));
+
+    start_wait_op(impl, p.p);
+    p.v = p.p = 0;
+  }
+
+  // Deliver notification that a particular signal occurred.
+  BOOST_ASIO_DECL static void deliver_signal(int signal_number);
+
+private:
+  // Helper function to add a service to the global signal state.
+  BOOST_ASIO_DECL static void add_service(signal_set_service* service);
+
+  // Helper function to remove a service from the global signal state.
+  BOOST_ASIO_DECL static void remove_service(signal_set_service* service);
+
+  // Helper function to create the pipe descriptors.
+  BOOST_ASIO_DECL static void open_descriptors();
+
+  // Helper function to close the pipe descriptors.
+  BOOST_ASIO_DECL static void close_descriptors();
+
+  // Helper function to start a wait operation.
+  BOOST_ASIO_DECL void start_wait_op(implementation_type& impl, signal_op* op);
+
+  // The io_service instance used for dispatching handlers.
+  io_service_impl& io_service_;
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+  // The type used for registering for pipe reactor notifications.
+  class pipe_read_op;
+
+  // The reactor used for waiting for pipe readiness.
+  reactor& reactor_;
+
+  // The per-descriptor reactor data used for the pipe.
+  reactor::per_descriptor_data reactor_data_;
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+  // A mapping from signal number to the registered signal sets.
+  registration* registrations_[max_signal_number];
+
+  // Pointers to adjacent services in linked list.
+  signal_set_service* next_;
+  signal_set_service* prev_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/signal_set_service.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
index 18a8131..9d1644c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
@@ -51,7 +51,10 @@ enum
   stream_oriented = 16,
 
   // The socket is datagram-oriented.
-  datagram_oriented = 32
+  datagram_oriented = 32,
+
+  // The socket may have been dup()-ed.
+  possible_dup = 64
 };
 
 typedef unsigned char state_type;
@@ -88,8 +91,11 @@ BOOST_ASIO_DECL int bind(socket_type s, const socket_addr_type* addr,
 BOOST_ASIO_DECL int close(socket_type s, state_type& state,
     bool destruction, boost::system::error_code& ec);
 
+BOOST_ASIO_DECL bool set_user_non_blocking(socket_type s,
+    state_type& state, bool value, boost::system::error_code& ec);
+
 BOOST_ASIO_DECL bool set_internal_non_blocking(socket_type s,
-    state_type& state, boost::system::error_code& ec);
+    state_type& state, bool value, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int shutdown(socket_type s,
     int what, boost::system::error_code& ec);
@@ -166,6 +172,27 @@ BOOST_ASIO_DECL bool non_blocking_recvfrom(socket_type s,
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
+BOOST_ASIO_DECL int recvmsg(socket_type s, buf* bufs, size_t count,
+    int in_flags, int& out_flags, boost::system::error_code& ec);
+
+BOOST_ASIO_DECL size_t sync_recvmsg(socket_type s, state_type state,
+    buf* bufs, size_t count, int in_flags, int& out_flags,
+    boost::system::error_code& ec);
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+BOOST_ASIO_DECL void complete_iocp_recvmsg(
+    const weak_cancel_token_type& cancel_token,
+    boost::system::error_code& ec);
+
+#else // defined(BOOST_ASIO_HAS_IOCP)
+
+BOOST_ASIO_DECL bool non_blocking_recvmsg(socket_type s,
+    buf* bufs, size_t count, int in_flags, int& out_flags,
+    boost::system::error_code& ec, size_t& bytes_transferred);
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
 BOOST_ASIO_DECL int send(socket_type s, const buf* bufs,
     size_t count, int flags, boost::system::error_code& ec);
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
index 6d68d5a..70e6084 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
@@ -38,6 +38,9 @@ public:
   // Destructor.
   BOOST_ASIO_DECL ~socket_select_interrupter();
 
+  // Recreate the interrupter's descriptors. Used after a fork.
+  BOOST_ASIO_DECL void recreate();
+
   // Interrupt the select call.
   BOOST_ASIO_DECL void interrupt();
 
@@ -51,6 +54,12 @@ public:
   }
 
 private:
+  // Open the descriptors. Throws on error.
+  BOOST_ASIO_DECL void open_descriptors();
+
+  // Close the descriptors.
+  BOOST_ASIO_DECL void close_descriptors();
+
   // The read end of a connection used to interrupt the select call. This file
   // descriptor is passed to select such that when it is time to stop, a single
   // byte will be written on the other end of the connection and this
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
index f0679b6..76e8ee9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
@@ -113,6 +113,7 @@ const int shutdown_both = SD_BOTH;
 const int message_peek = MSG_PEEK;
 const int message_out_of_band = MSG_OOB;
 const int message_do_not_route = MSG_DONTROUTE;
+const int message_end_of_record = 0; // Not supported on Windows.
 # if defined (_WIN32_WINNT)
 const int max_iov_len = 64;
 # else
@@ -156,6 +157,7 @@ const int shutdown_both = SHUT_RDWR;
 const int message_peek = MSG_PEEK;
 const int message_out_of_band = MSG_OOB;
 const int message_do_not_route = MSG_DONTROUTE;
+const int message_end_of_record = MSG_EOR;
 # if defined(IOV_MAX)
 const int max_iov_len = IOV_MAX;
 # else
diff --git a/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp
new file mode 100644
index 0000000..e77a713
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp
@@ -0,0 +1,49 @@
+//
+// detail/static_mutex.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_DETAIL_STATIC_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_STATIC_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+# include <boost/asio/detail/null_static_mutex.hpp>
+#elif defined(BOOST_WINDOWS)
+# include <boost/asio/detail/win_static_mutex.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+# include <boost/asio/detail/posix_static_mutex.hpp>
+#else
+# error Only Windows and POSIX are supported!
+#endif
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+typedef null_static_mutex static_mutex;
+# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_NULL_STATIC_MUTEX_INIT
+#elif defined(BOOST_WINDOWS)
+typedef win_static_mutex static_mutex;
+# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_WIN_STATIC_MUTEX_INIT
+#elif defined(BOOST_HAS_PTHREADS)
+typedef posix_static_mutex static_mutex;
+# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_POSIX_STATIC_MUTEX_INIT
+#endif
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp b/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
index 0783ac4..ae11184 100644
--- a/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
@@ -16,11 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/scoped_ptr.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/operation.hpp>
+#include <boost/asio/detail/scoped_ptr.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -87,6 +87,13 @@ public:
   void post(implementation_type& impl, Handler handler);
 
 private:
+  // Helper function to dispatch a handler. Returns true if the handler should
+  // be dispatched immediately.
+  BOOST_ASIO_DECL bool do_dispatch(implementation_type& impl, operation* op);
+
+  // Helper fiunction to post a handler.
+  BOOST_ASIO_DECL void do_post(implementation_type& impl, operation* op);
+
   BOOST_ASIO_DECL static void do_complete(io_service_impl* owner,
       operation* base, boost::system::error_code ec,
       std::size_t bytes_transferred);
@@ -100,8 +107,8 @@ private:
   // Number of implementations shared between all strand objects.
   enum { num_implementations = 193 };
 
-  // The head of a linked list of all implementations.
-  boost::scoped_ptr<strand_impl> implementations_[num_implementations];
+  // Pool of implementations.
+  scoped_ptr<strand_impl> implementations_[num_implementations];
 
   // Extra value used when hashing to prevent recycled memory locations from
   // getting the same strand implementation.
diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
index c014855..08e7a57 100644
--- a/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
@@ -19,9 +19,9 @@
 
 #if !defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/detail/atomic_count.hpp>
 #include <boost/system/error_code.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/atomic_count.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_fwd.hpp>
@@ -67,6 +67,9 @@ public:
   // Interrupt the event processing loop.
   BOOST_ASIO_DECL void stop();
 
+  // Determine whether the io_service is stopped.
+  BOOST_ASIO_DECL bool stopped() const;
+
   // Reset in preparation for a subsequent run invocation.
   BOOST_ASIO_DECL void reset();
 
@@ -103,6 +106,10 @@ public:
   // that work_started() was previously called for each operation.
   BOOST_ASIO_DECL void post_deferred_completions(op_queue<operation>& ops);
 
+  // Process unfinished operations as part of a shutdown_service operation.
+  // Assumes that work_started() was previously called for the operations.
+  BOOST_ASIO_DECL void abandon_operations(op_queue<operation>& ops);
+
 private:
   // Structure containing information about an idle thread.
   struct idle_thread_info;
@@ -132,7 +139,7 @@ private:
   struct work_finished_on_block_exit;
 
   // Mutex to protect access to internal data.
-  mutex mutex_;
+  mutable mutex mutex_;
 
   // The task to be run by this service.
   reactor* task_;
@@ -147,7 +154,7 @@ private:
   bool task_interrupted_;
 
   // The count of unfinished work.
-  boost::detail::atomic_count outstanding_work_;
+  atomic_count outstanding_work_;
 
   // The queue of handlers that are ready to be delivered.
   op_queue<operation> op_queue_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp
index 08164fa..72cbefd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/system/error_code.hpp>
+#include <boost/asio/detail/handler_tracking.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/task_io_service_fwd.hpp>
 
@@ -27,7 +28,7 @@ namespace detail {
 
 // Base class for all operations. A function pointer is used instead of virtual
 // functions to avoid the associated overhead.
-class task_io_service_operation
+class task_io_service_operation BOOST_ASIO_INHERIT_TRACKED_HANDLER
 {
 public:
   void complete(task_io_service& owner)
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
index 328a9ed..78974a4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
@@ -183,20 +183,23 @@ public:
     heap_.clear();
   }
 
-  // Cancel and dequeue the timers with the given token.
-  std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops)
+  // Cancel and dequeue operations for the given timer.
+  std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
   {
     std::size_t num_cancelled = 0;
     if (timer.prev_ != 0 || &timer == timers_)
     {
-      while (timer_op* op = timer.op_queue_.front())
+      while (timer_op* op = (num_cancelled != max_cancelled)
+          ? timer.op_queue_.front() : 0)
       {
         op->ec_ = boost::asio::error::operation_aborted;
         timer.op_queue_.pop();
         ops.push(op);
         ++num_cancelled;
       }
-      remove_timer(timer);
+      if (timer.op_queue_.empty())
+        remove_timer(timer);
     }
     return num_cancelled;
   }
@@ -354,9 +357,10 @@ public:
   // Dequeue all timers.
   BOOST_ASIO_DECL virtual void get_all_timers(op_queue<operation>& ops);
 
-  // Cancel and dequeue the timers with the given token.
+  // Cancel and dequeue operations for the given timer.
   BOOST_ASIO_DECL std::size_t cancel_timer(
-      per_timer_data& timer, op_queue<operation>& ops);
+      per_timer_data& timer, op_queue<operation>& ops,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
 private:
   timer_queue<forwarding_posix_time_traits> impl_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
index 95be6bd..77fedf7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
@@ -33,9 +33,9 @@ class wait_handler : public timer_op
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(wait_handler);
 
-  wait_handler(Handler h)
+  wait_handler(Handler& h)
     : timer_op(&wait_handler::do_complete),
-      handler_(h)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
   {
   }
 
@@ -46,6 +46,8 @@ public:
     wait_handler* h(static_cast<wait_handler*>(base));
     ptr p = { boost::addressof(h->handler_), h, h };
 
+    BOOST_ASIO_HANDLER_COMPLETION((h));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -61,7 +63,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
index 81a8b06..4ca617d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
@@ -16,23 +16,22 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/version.hpp>
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1600)
+#if defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 # include <memory>
-#else
+#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 # include <boost/weak_ptr.hpp>
-#endif
+#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1600)
+#if defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 using std::weak_ptr;
-#else
+#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 using boost::weak_ptr;
-#endif
+#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 
 } // namespace detail
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp
index 5edffa3..c7c2456 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp
@@ -41,10 +41,11 @@ class win_iocp_handle_read_op : public operation
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_read_op);
 
-  win_iocp_handle_read_op(const MutableBufferSequence& buffers, Handler handler)
+  win_iocp_handle_read_op(
+      const MutableBufferSequence& buffers, Handler& handler)
     : operation(&win_iocp_handle_read_op::do_complete),
       buffers_(buffers),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -55,6 +56,8 @@ public:
     win_iocp_handle_read_op* o(static_cast<win_iocp_handle_read_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
     {
@@ -83,7 +86,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp
index 86c4391..444838d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp
@@ -41,7 +41,7 @@ class win_iocp_handle_service
 {
 public:
   // The native type of a stream handle.
-  typedef HANDLE native_type;
+  typedef HANDLE native_handle_type;
 
   // The implementation type of the stream handle.
   class implementation_type
@@ -61,7 +61,7 @@ public:
     friend class win_iocp_handle_service;
 
     // The native stream handle representation.
-    native_type handle_;
+    native_handle_type handle_;
 
     // The ID of the thread from which it is safe to cancel asynchronous
     // operations. 0 means no asynchronous operations have been started yet.
@@ -82,12 +82,21 @@ public:
   // Construct a new handle implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
+  // Move-construct a new handle implementation.
+  BOOST_ASIO_DECL void move_construct(implementation_type& impl,
+      implementation_type& other_impl);
+
+  // Move-assign from another handle implementation.
+  BOOST_ASIO_DECL void move_assign(implementation_type& impl,
+      win_iocp_handle_service& other_service,
+      implementation_type& other_impl);
+
   // Destroy a handle implementation.
   BOOST_ASIO_DECL void destroy(implementation_type& impl);
 
   // Assign a native handle to a handle implementation.
   BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_handle, boost::system::error_code& ec);
+      const native_handle_type& handle, boost::system::error_code& ec);
 
   // Determine whether the handle is open.
   bool is_open(const implementation_type& impl) const
@@ -100,7 +109,7 @@ public:
       boost::system::error_code& ec);
 
   // Get the native handle representation.
-  native_type native(const implementation_type& impl) const
+  native_handle_type native_handle(const implementation_type& impl) const
   {
     return impl.handle_;
   }
@@ -136,7 +145,19 @@ public:
   void async_write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, Handler handler)
   {
-    async_write_some_at(impl, 0, buffers, handler);
+    // Allocate and construct an operation to wrap the handler.
+    typedef win_iocp_handle_write_op<ConstBufferSequence, Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(buffers, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some"));
+
+    start_write_op(impl, 0,
+        buffer_sequence_adapter<boost::asio::const_buffer,
+          ConstBufferSequence>::first(buffers), p.p);
+    p.v = p.p = 0;
   }
 
   // Start an asynchronous write at a specified offset. The data being written
@@ -152,6 +173,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some_at"));
+
     start_write_op(impl, offset,
         buffer_sequence_adapter<boost::asio::const_buffer,
           ConstBufferSequence>::first(buffers), p.p);
@@ -184,7 +207,19 @@ public:
   void async_read_some(implementation_type& impl,
       const MutableBufferSequence& buffers, Handler handler)
   {
-    async_read_some_at(impl, 0, buffers, handler);
+    // Allocate and construct an operation to wrap the handler.
+    typedef win_iocp_handle_read_op<MutableBufferSequence, Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(buffers, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some"));
+
+    start_read_op(impl, 0,
+        buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::first(buffers), p.p);
+    p.v = p.p = 0;
   }
 
   // Start an asynchronous read at a specified offset. The buffer for the data
@@ -201,6 +236,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some_at"));
+
     start_read_op(impl, offset,
         buffer_sequence_adapter<boost::asio::mutable_buffer,
           MutableBufferSequence>::first(buffers), p.p);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp
index 574dc22..510b092 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp
@@ -41,10 +41,10 @@ class win_iocp_handle_write_op : public operation
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_write_op);
 
-  win_iocp_handle_write_op(const ConstBufferSequence& buffers, Handler handler)
+  win_iocp_handle_write_op(const ConstBufferSequence& buffers, Handler& handler)
     : operation(&win_iocp_handle_write_op::do_complete),
       buffers_(buffers),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -55,6 +55,8 @@ public:
     win_iocp_handle_write_op* o(static_cast<win_iocp_handle_write_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
     {
@@ -79,7 +81,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp
index 4c88e7b..09ee612 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp
@@ -19,10 +19,11 @@
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/scoped_ptr.hpp>
+#include <boost/limits.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/detail/scoped_ptr.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_op.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -76,6 +77,12 @@ public:
   // Stop the event processing loop.
   BOOST_ASIO_DECL void stop();
 
+  // Determine whether the io_service is stopped.
+  bool stopped() const
+  {
+    return ::InterlockedExchangeAdd(&stopped_, 0) != 0;
+  }
+
   // Reset in preparation for a subsequent run invocation.
   void reset()
   {
@@ -120,6 +127,10 @@ public:
   BOOST_ASIO_DECL void post_deferred_completions(
       op_queue<win_iocp_operation>& ops);
 
+  // Process unfinished operations as part of a shutdown_service operation.
+  // Assumes that work_started() was previously called for the operations.
+  BOOST_ASIO_DECL void abandon_operations(op_queue<operation>& ops);
+
   // Called after starting an overlapped I/O operation that did not complete
   // immediately. The caller must have already called work_started() prior to
   // starting the operation.
@@ -156,7 +167,8 @@ public:
   // handlers that have been posted or dispatched.
   template <typename Time_Traits>
   std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer);
+      typename timer_queue<Time_Traits>::per_timer_data& timer,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
 private:
 #if defined(WINVER) && (WINVER < 0x0500)
@@ -199,7 +211,7 @@ private:
   long outstanding_work_;
 
   // Flag to indicate whether the event loop has been stopped.
-  long stopped_;
+  mutable long stopped_;
 
   // Flag to indicate whether the service has been shut down.
   long shutdown_;
@@ -233,7 +245,7 @@ private:
   friend struct timer_thread_function;
 
   // Background thread used for processing timeouts.
-  boost::scoped_ptr<thread> timer_thread_;
+  scoped_ptr<thread> timer_thread_;
 
   // A waitable timer object used for waiting for timeouts.
   auto_handle waitable_timer_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp
index b3ecbbd..ee0646a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp
@@ -42,11 +42,11 @@ public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_null_buffers_op);
 
   win_iocp_null_buffers_op(socket_ops::weak_cancel_token_type cancel_token,
-      Handler handler)
+      Handler& handler)
     : reactor_op(&win_iocp_null_buffers_op::do_perform,
         &win_iocp_null_buffers_op::do_complete),
       cancel_token_(cancel_token),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -62,6 +62,8 @@ public:
     win_iocp_null_buffers_op* o(static_cast<win_iocp_null_buffers_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // The reactor may have stored a result in the operation object.
     if (o->ec_)
       ec = o->ec_;
@@ -94,7 +96,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
index 3963479..2893d89 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
@@ -19,6 +19,7 @@
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
+#include <boost/asio/detail/handler_tracking.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
 #include <boost/system/error_code.hpp>
@@ -33,6 +34,7 @@ namespace detail {
 // functions to avoid the associated overhead.
 class win_iocp_operation
   : public OVERLAPPED
+    BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
 {
 public:
   void complete(win_iocp_io_service& owner,
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp
index 149eaa5..f22c382 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp
@@ -39,9 +39,9 @@ class win_iocp_overlapped_op : public operation
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_overlapped_op);
 
-  win_iocp_overlapped_op(Handler handler)
+  win_iocp_overlapped_op(Handler& handler)
     : operation(&win_iocp_overlapped_op::do_complete),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -52,6 +52,8 @@ public:
     win_iocp_overlapped_op* o(static_cast<win_iocp_overlapped_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -67,7 +69,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp
index c560bc3..db6c852 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp
@@ -47,11 +47,11 @@ public:
   // Construct an win_iocp_overlapped_ptr to contain the specified handler.
   template <typename Handler>
   explicit win_iocp_overlapped_ptr(
-      boost::asio::io_service& io_service, Handler handler)
+      boost::asio::io_service& io_service, BOOST_ASIO_MOVE_ARG(Handler) handler)
     : ptr_(0),
       iocp_service_(0)
   {
-    this->reset(io_service, handler);
+    this->reset(io_service, BOOST_ASIO_MOVE_CAST(Handler)(handler));
   }
 
   // Destructor automatically frees the OVERLAPPED object unless released.
@@ -82,6 +82,10 @@ public:
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "io_service",
+          &io_service.impl_, "overlapped"));
+
     io_service.impl_.work_started();
     reset();
     ptr_ = p.p;
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp
index 8b543d2..bf7099a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp
@@ -36,7 +36,7 @@ class win_iocp_serial_port_service
 {
 public:
   // The native type of a serial port.
-  typedef win_iocp_handle_service::native_type native_type;
+  typedef win_iocp_handle_service::native_handle_type native_handle_type;
 
   // The implementation type of the serial port.
   typedef win_iocp_handle_service::implementation_type implementation_type;
@@ -54,6 +54,22 @@ public:
     handle_service_.construct(impl);
   }
 
+  // Move-construct a new serial port implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    handle_service_.move_construct(impl, other_impl);
+  }
+
+  // Move-assign from another serial port implementation.
+  void move_assign(implementation_type& impl,
+      win_iocp_serial_port_service& other_service,
+      implementation_type& other_impl)
+  {
+    handle_service_.move_assign(impl,
+        other_service.handle_service_, other_impl);
+  }
+
   // Destroy a serial port implementation.
   void destroy(implementation_type& impl)
   {
@@ -66,9 +82,9 @@ public:
 
   // Assign a native handle to a serial port implementation.
   boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_handle, boost::system::error_code& ec)
+      const native_handle_type& handle, boost::system::error_code& ec)
   {
-    return handle_service_.assign(impl, native_handle, ec);
+    return handle_service_.assign(impl, handle, ec);
   }
 
   // Determine whether the serial port is open.
@@ -85,9 +101,9 @@ public:
   }
 
   // Get the native serial port representation.
-  native_type native(implementation_type& impl)
+  native_handle_type native_handle(implementation_type& impl)
   {
-    return handle_service_.native(impl);
+    return handle_service_.native_handle(impl);
   }
 
   // Cancel all operations associated with the handle.
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp
index ecc1f2d..c15d06f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp
@@ -45,7 +45,7 @@ public:
   win_iocp_socket_accept_op(win_iocp_socket_service_base& socket_service,
       socket_type socket, Socket& peer, const Protocol& protocol,
       typename Protocol::endpoint* peer_endpoint,
-      bool enable_connection_aborted, Handler handler)
+      bool enable_connection_aborted, Handler& handler)
     : operation(&win_iocp_socket_accept_op::do_complete),
       socket_service_(socket_service),
       socket_(socket),
@@ -53,7 +53,7 @@ public:
       protocol_(protocol),
       peer_endpoint_(peer_endpoint),
       enable_connection_aborted_(enable_connection_aborted),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -107,7 +107,7 @@ public:
       if (!ec)
       {
         o->peer_.assign(o->protocol_,
-            typename Socket::native_type(
+            typename Socket::native_handle_type(
               o->new_socket_.get(), peer_endpoint), ec);
         if (!ec)
           o->new_socket_.release();
@@ -118,6 +118,8 @@ public:
         *o->peer_endpoint_ = peer_endpoint;
     }
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -133,7 +135,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp
index 61d053c..cae85fd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp
@@ -43,12 +43,12 @@ public:
 
   win_iocp_socket_recv_op(socket_ops::state_type state,
       socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers, Handler handler)
+      const MutableBufferSequence& buffers, Handler& handler)
     : operation(&win_iocp_socket_recv_op::do_complete),
       state_(state),
       cancel_token_(cancel_token),
       buffers_(buffers),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -59,6 +59,8 @@ public:
     win_iocp_socket_recv_op* o(static_cast<win_iocp_socket_recv_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -88,7 +90,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
index 6b364ee..f2c38fa 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
@@ -43,13 +43,13 @@ public:
 
   win_iocp_socket_recvfrom_op(Endpoint& endpoint,
       socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers, Handler handler)
+      const MutableBufferSequence& buffers, Handler& handler)
     : operation(&win_iocp_socket_recvfrom_op::do_complete),
       endpoint_(endpoint),
       endpoint_size_(static_cast<int>(endpoint.capacity())),
       cancel_token_(cancel_token),
       buffers_(buffers),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -66,6 +66,8 @@ public:
         static_cast<win_iocp_socket_recvfrom_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -95,7 +97,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
new file mode 100644
index 0000000..6ee6113
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
@@ -0,0 +1,115 @@
+//
+// detail/win_iocp_socket_recvmsg_op.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_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/operation.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/socket_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence, typename Handler>
+class win_iocp_socket_recvmsg_op : public operation
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recvmsg_op);
+
+  win_iocp_socket_recvmsg_op(
+      socket_ops::weak_cancel_token_type cancel_token,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags& out_flags, Handler& handler)
+    : operation(&win_iocp_socket_recvmsg_op::do_complete),
+      cancel_token_(cancel_token),
+      buffers_(buffers),
+      out_flags_(out_flags),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      boost::system::error_code ec, std::size_t bytes_transferred)
+  {
+    // Take ownership of the operation object.
+    win_iocp_socket_recvmsg_op* o(
+        static_cast<win_iocp_socket_recvmsg_op*>(base));
+    ptr p = { boost::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+    // Check whether buffers are still valid.
+    if (owner)
+    {
+      buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::validate(o->buffers_);
+    }
+#endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+
+    socket_ops::complete_iocp_recvmsg(o->cancel_token_, ec);
+    o->out_flags_ = 0;
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, ec, bytes_transferred);
+    p.h = boost::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  socket_ops::weak_cancel_token_type cancel_token_;
+  MutableBufferSequence buffers_;
+  socket_base::message_flags& out_flags_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp
index 33bd380..c8a49a3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp
@@ -42,11 +42,11 @@ public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_send_op);
 
   win_iocp_socket_send_op(socket_ops::weak_cancel_token_type cancel_token,
-      const ConstBufferSequence& buffers, Handler handler)
+      const ConstBufferSequence& buffers, Handler& handler)
     : operation(&win_iocp_socket_send_op::do_complete),
       cancel_token_(cancel_token),
       buffers_(buffers),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -57,6 +57,8 @@ public:
     win_iocp_socket_send_op* o(static_cast<win_iocp_socket_send_op*>(base));
     ptr p = { boost::addressof(o->handler_), o, o };
 
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -83,7 +85,9 @@ public:
     if (owner)
     {
       boost::asio::detail::fenced_block b;
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp
index 183b74b..a7dfbfb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp
@@ -61,16 +61,16 @@ public:
   typedef typename Protocol::endpoint endpoint_type;
 
   // The native type of a socket.
-  class native_type
+  class native_handle_type
   {
   public:
-    native_type(socket_type s)
+    native_handle_type(socket_type s)
       : socket_(s),
         have_remote_endpoint_(false)
     {
     }
 
-    native_type(socket_type s, const endpoint_type& ep)
+    native_handle_type(socket_type s, const endpoint_type& ep)
       : socket_(s),
         have_remote_endpoint_(true),
         remote_endpoint_(ep)
@@ -133,6 +133,39 @@ public:
   {
   }
 
+  // Move-construct a new socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+
+    impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_;
+    other_impl.have_remote_endpoint_ = false;
+
+    impl.remote_endpoint_ = other_impl.remote_endpoint_;
+    other_impl.remote_endpoint_ = endpoint_type();
+  }
+
+  // Move-assign from another socket implementation.
+  void move_assign(implementation_type& impl,
+      win_iocp_socket_service_base& other_service,
+      implementation_type& other_impl)
+  {
+    this->base_move_assign(impl, other_service, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+
+    impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_;
+    other_impl.have_remote_endpoint_ = false;
+
+    impl.remote_endpoint_ = other_impl.remote_endpoint_;
+    other_impl.remote_endpoint_ = endpoint_type();
+  }
+
   // Open a new socket implementation.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
@@ -149,7 +182,7 @@ public:
 
   // Assign a native socket to a socket implementation.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_type& native_socket,
+      const protocol_type& protocol, const native_handle_type& native_socket,
       boost::system::error_code& ec)
   {
     if (!do_assign(impl, protocol.type(), native_socket, ec))
@@ -162,11 +195,11 @@ public:
   }
 
   // Get the native socket representation.
-  native_type native(implementation_type& impl)
+  native_handle_type native_handle(implementation_type& impl)
   {
     if (impl.have_remote_endpoint_)
-      return native_type(impl.socket_, impl.remote_endpoint_);
-    return native_type(impl.socket_);
+      return native_handle_type(impl.socket_, impl.remote_endpoint_);
+    return native_handle_type(impl.socket_);
   }
 
   // Bind the socket to the specified local endpoint.
@@ -267,6 +300,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to"));
+
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
@@ -288,6 +323,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_send_to(null_buffers)"));
+
     start_reactor_op(impl, reactor::write_op, p.p);
     p.v = p.p = 0;
   }
@@ -344,6 +382,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(sender_endp, impl.cancel_token_, buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_from"));
+
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
@@ -365,6 +405,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl,
+          "async_receive_from(null_buffers)"));
+
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
 
@@ -417,6 +460,8 @@ public:
     p.p = new (p.v) op(*this, impl.socket_, peer, impl.protocol_,
         peer_endpoint, enable_connection_aborted, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_accept"));
+
     start_accept_op(impl, peer.is_open(), p.p->new_socket(),
         impl.protocol_.family(), impl.protocol_.type(),
         impl.protocol_.protocol(), p.p->output_buffer(),
@@ -445,6 +490,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
+
     start_connect_op(impl, p.p, peer_endpoint.data(),
         static_cast<int>(peer_endpoint.size()));
     p.v = p.p = 0;
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp
index 32532f9..21062ee 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp
@@ -40,6 +40,7 @@
 #include <boost/asio/detail/win_iocp_null_buffers_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_send_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_recv_op.hpp>
+#include <boost/asio/detail/win_iocp_socket_recvmsg_op.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -93,6 +94,15 @@ public:
   // Construct a new socket implementation.
   BOOST_ASIO_DECL void construct(base_implementation_type& impl);
 
+  // Move-construct a new socket implementation.
+  BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl,
+      base_implementation_type& other_impl);
+
+  // Move-assign from another socket implementation.
+  BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl,
+      win_iocp_socket_service_base& other_service,
+      base_implementation_type& other_impl);
+
   // Destroy a socket implementation.
   BOOST_ASIO_DECL void destroy(base_implementation_type& impl);
 
@@ -142,7 +152,35 @@ public:
     return ec;
   }
 
-  /// Disable sends or receives on the socket.
+  // Gets the non-blocking mode of the socket.
+  bool non_blocking(const base_implementation_type& impl) const
+  {
+    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(base_implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const base_implementation_type& impl) const
+  {
+    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(base_implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Disable sends or receives on the socket.
   boost::system::error_code shutdown(base_implementation_type& impl,
       socket_base::shutdown_type what, boost::system::error_code& ec)
   {
@@ -187,6 +225,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
+
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
@@ -208,6 +248,9 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_send(null_buffers)"));
+
     start_reactor_op(impl, reactor::write_op, p.p);
     p.v = p.p = 0;
   }
@@ -249,6 +292,8 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.state_, impl.cancel_token_, buffers, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
+
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
@@ -270,10 +315,90 @@ public:
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_receive(null_buffers)"));
+
     start_null_buffers_receive_op(impl, flags, p.p);
     p.v = p.p = 0;
   }
 
+  // Receive some data with associated flags. Returns the number of bytes
+  // received.
+  template <typename MutableBufferSequence>
+  size_t receive_with_flags(base_implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs(buffers);
+
+    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
+        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
+  }
+
+  // Wait until data can be received without blocking.
+  size_t receive_with_flags(base_implementation_type& impl,
+      const null_buffers&, socket_base::message_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    // Wait for socket to become ready.
+    socket_ops::poll_read(impl.socket_, ec);
+
+    // Clear out_flags, since we cannot give it any other sensible value when
+    // performing a null_buffers operation.
+    out_flags = 0;
+
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence, typename Handler>
+  void async_receive_with_flags(base_implementation_type& impl,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef win_iocp_socket_recvmsg_op<MutableBufferSequence, Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(impl.cancel_token_, buffers, out_flags, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
+          &impl, "async_receive_with_flags"));
+
+    buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs(buffers);
+
+    start_receive_op(impl, bufs.buffers(), bufs.count(), in_flags, false, p.p);
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler>
+  void async_receive_with_flags(base_implementation_type& impl,
+      const null_buffers&, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef win_iocp_null_buffers_op<Handler> op;
+    typename op::ptr p = { boost::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(impl.cancel_token_, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl,
+          "async_receive_with_flags(null_buffers)"));
+
+    // Reset out_flags since it can be given no sensible value at this time.
+    out_flags = 0;
+
+    start_null_buffers_receive_op(impl, in_flags, p.p);
+    p.v = p.p = 0;
+  }
+
   // Helper function to restart an asynchronous accept operation.
   BOOST_ASIO_DECL void restart_accept_op(socket_type s,
       socket_holder& new_socket, int family, int type, int protocol,
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp
new file mode 100644
index 0000000..b6791c2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp
@@ -0,0 +1,76 @@
+//
+// detail/win_static_mutex.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_DETAIL_WIN_STATIC_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_WINDOWS)
+
+#include <boost/asio/detail/scoped_lock.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+struct win_static_mutex
+{
+  typedef boost::asio::detail::scoped_lock<win_static_mutex> scoped_lock;
+
+  // Initialise the mutex.
+  BOOST_ASIO_DECL void init();
+
+  // Initialisation must be performed in a separate function to the "public"
+  // init() function since the compiler does not support the use of structured
+  // exceptions and C++ exceptions in the same function.
+  BOOST_ASIO_DECL int do_init();
+
+  // Lock the mutex.
+  void lock()
+  {
+    ::EnterCriticalSection(&crit_section_);
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+    ::LeaveCriticalSection(&crit_section_);
+  }
+
+  bool initialised_;
+  ::CRITICAL_SECTION crit_section_;
+};
+
+#if defined(UNDER_CE)
+# define BOOST_ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0 } }
+#else // defined(UNDER_CE)
+# define BOOST_ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0, 0 } }
+#endif // defined(UNDER_CE)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/win_static_mutex.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_WINDOWS)
+
+#endif // BOOST_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
index 7f7b1e4..8d5ede8 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
@@ -39,7 +39,7 @@ class wince_thread
 public:
   // Constructor.
   template <typename Function>
-  wince_thread(Function f)
+  wince_thread(Function f, unsigned int = 0)
   {
     std::auto_ptr<func_base> arg(new func<Function>(f));
     DWORD thread_id = 0;
diff --git a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
index b326847..dcff1c9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
@@ -31,12 +31,26 @@ class wrapped_handler
 public:
   typedef void result_type;
 
-  wrapped_handler(Dispatcher dispatcher, Handler handler)
+  wrapped_handler(Dispatcher dispatcher, Handler& handler)
     : dispatcher_(dispatcher),
-      handler_(handler)
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+  wrapped_handler(const wrapped_handler& other)
+    : dispatcher_(other.dispatcher_),
+      handler_(other.handler_)
+  {
+  }
+
+  wrapped_handler(wrapped_handler&& other)
+    : dispatcher_(other.dispatcher_),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_))
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
   void operator()()
   {
     dispatcher_.dispatch(handler_);
@@ -126,11 +140,31 @@ template <typename Handler, typename Context>
 class rewrapped_handler
 {
 public:
+  explicit rewrapped_handler(Handler& handler, const Context& context)
+    : context_(context),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
   explicit rewrapped_handler(const Handler& handler, const Context& context)
-    : handler_(handler),
-      context_(context)
+    : context_(context),
+      handler_(handler)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  rewrapped_handler(const rewrapped_handler& other)
+    : context_(other.context_),
+      handler_(other.handler_)
+  {
+  }
+
+  rewrapped_handler(rewrapped_handler&& other)
+    : context_(BOOST_ASIO_MOVE_CAST(Context)(other.context_)),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_))
   {
   }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
 
   void operator()()
   {
@@ -143,8 +177,8 @@ public:
   }
 
 //private:
-  Handler handler_;
   Context context_;
+  Handler handler_;
 };
 
 template <typename Dispatcher, typename Handler>
@@ -164,6 +198,15 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
 }
 
 template <typename Function, typename Dispatcher, typename Handler>
+inline void asio_handler_invoke(Function& function,
+    wrapped_handler<Dispatcher, Handler>* this_handler)
+{
+  this_handler->dispatcher_.dispatch(
+      rewrapped_handler<Function, Handler>(
+        function, this_handler->handler_));
+}
+
+template <typename Function, typename Dispatcher, typename Handler>
 inline void asio_handler_invoke(const Function& function,
     wrapped_handler<Dispatcher, Handler>* this_handler)
 {
@@ -189,6 +232,14 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
 }
 
 template <typename Function, typename Handler, typename Context>
+inline void asio_handler_invoke(Function& function,
+    rewrapped_handler<Handler, Context>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->context_);
+}
+
+template <typename Function, typename Handler, typename Context>
 inline void asio_handler_invoke(const Function& function,
     rewrapped_handler<Handler, Context>* this_handler)
 {
diff --git a/3rdParty/Boost/src/boost/asio/error.hpp b/3rdParty/Boost/src/boost/asio/error.hpp
index d0287a0..355c8a1 100644
--- a/3rdParty/Boost/src/boost/asio/error.hpp
+++ b/3rdParty/Boost/src/boost/asio/error.hpp
@@ -211,10 +211,6 @@ enum misc_errors
   fd_set_failure
 };
 
-enum ssl_errors
-{
-};
-
 inline const boost::system::error_category& get_system_category()
 {
   return boost::system::system_category();
@@ -245,9 +241,6 @@ inline const boost::system::error_category& get_addrinfo_category()
 extern BOOST_ASIO_DECL
 const boost::system::error_category& get_misc_category();
 
-extern BOOST_ASIO_DECL
-const boost::system::error_category& get_ssl_category();
-
 static const boost::system::error_category& system_category
   = boost::asio::error::get_system_category();
 static const boost::system::error_category& netdb_category
@@ -256,12 +249,12 @@ static const boost::system::error_category& addrinfo_category
   = boost::asio::error::get_addrinfo_category();
 static const boost::system::error_category& misc_category
   = boost::asio::error::get_misc_category();
-static const boost::system::error_category& ssl_category
-  = boost::asio::error::get_ssl_category();
 
 } // namespace error
 } // namespace asio
+} // namespace boost
 
+namespace boost {
 namespace system {
 
 template<> struct is_error_code_enum<boost::asio::error::basic_errors>
@@ -284,13 +277,10 @@ template<> struct is_error_code_enum<boost::asio::error::misc_errors>
   static const bool value = true;
 };
 
-template<> struct is_error_code_enum<boost::asio::error::ssl_errors>
-{
-  static const bool value = true;
-};
-
 } // namespace system
+} // namespace boost
 
+namespace boost {
 namespace asio {
 namespace error {
 
@@ -318,12 +308,6 @@ inline boost::system::error_code make_error_code(misc_errors e)
       static_cast<int>(e), get_misc_category());
 }
 
-inline boost::system::error_code make_error_code(ssl_errors e)
-{
-  return boost::system::error_code(
-      static_cast<int>(e), get_ssl_category());
-}
-
 } // namespace error
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/impl/connect.hpp b/3rdParty/Boost/src/boost/asio/impl/connect.hpp
new file mode 100644
index 0000000..d0609f9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/impl/connect.hpp
@@ -0,0 +1,391 @@
+//
+// impl/connect.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_IMPL_CONNECT_HPP
+#define BOOST_ASIO_IMPL_CONNECT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/consuming_buffers.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+namespace detail
+{
+  struct default_connect_condition
+  {
+    template <typename Iterator>
+    Iterator operator()(const boost::system::error_code&, Iterator next)
+    {
+      return next;
+    }
+  };
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, boost::system::error_code& ec)
+{
+  return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, end, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, boost::system::error_code& ec)
+{
+  return connect(s, begin, end, detail::default_connect_condition(), ec);
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, ConnectCondition connect_condition)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, connect_condition, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, ConnectCondition connect_condition,
+    boost::system::error_code& ec)
+{
+  return connect(s, begin, Iterator(), connect_condition, ec);
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, end, connect_condition, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition,
+    boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+
+  for (Iterator iter = begin; iter != end; ++iter)
+  {
+    iter = connect_condition(ec, iter);
+    if (iter != end)
+    {
+      s.close(ec);
+      s.connect(*iter, ec);
+      if (!ec)
+        return iter;
+    }
+  }
+
+  if (!ec)
+    ec = boost::asio::error::not_found;
+
+  return end;
+}
+
+namespace detail
+{
+  // Enable the empty base class optimisation for the connect condition.
+  template <typename ConnectCondition>
+  class base_from_connect_condition
+  {
+  protected:
+    explicit base_from_connect_condition(
+        const ConnectCondition& connect_condition)
+      : connect_condition_(connect_condition)
+    {
+    }
+
+    template <typename Iterator>
+    void check_condition(const boost::system::error_code& ec,
+        Iterator& iter, Iterator& end)
+    {
+      if (iter != end)
+        iter = connect_condition_(ec, static_cast<const Iterator&>(iter));
+    }
+
+  private:
+    ConnectCondition connect_condition_;
+  };
+
+  // The default_connect_condition implementation is essentially a no-op. This
+  // template specialisation lets us eliminate all costs associated with it.
+  template <>
+  class base_from_connect_condition<default_connect_condition>
+  {
+  protected:
+    explicit base_from_connect_condition(const default_connect_condition&)
+    {
+    }
+
+    template <typename Iterator>
+    void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
+    {
+    }
+  };
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  class connect_op : base_from_connect_condition<ConnectCondition>
+  {
+  public:
+    connect_op(basic_socket<Protocol, SocketService>& sock,
+        const Iterator& begin, const Iterator& end,
+        const ConnectCondition& connect_condition,
+        ComposedConnectHandler& handler)
+      : base_from_connect_condition<ConnectCondition>(connect_condition),
+        socket_(sock),
+        iter_(begin),
+        end_(end),
+        handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    connect_op(const connect_op& other)
+      : base_from_connect_condition<ConnectCondition>(other),
+        socket_(other.socket_),
+        iter_(other.iter_),
+        end_(other.end_),
+        handler_(other.handler_)
+    {
+    }
+
+    connect_op(connect_op&& other)
+      : base_from_connect_condition<ConnectCondition>(other),
+        socket_(other.socket_),
+        iter_(other.iter_),
+        end_(other.end_),
+        handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(boost::system::error_code ec, int start = 0)
+    {
+      switch (start)
+      {
+        case 1:
+        for (;;)
+        {
+          this->check_condition(ec, iter_, end_);
+
+          if (iter_ != end_)
+          {
+            socket_.close(ec);
+            socket_.async_connect(*iter_,
+                BOOST_ASIO_MOVE_CAST(connect_op)(*this));
+            return;
+          }
+
+          if (start)
+          {
+            ec = boost::asio::error::not_found;
+            socket_.get_io_service().post(detail::bind_handler(*this, ec));
+            return;
+          }
+
+          default:
+
+          if (iter_ == end_)
+            break;
+
+          if (!socket_.is_open())
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+
+          if (!ec)
+            break;
+
+          ++iter_;
+        }
+
+        handler_(static_cast<const boost::system::error_code&>(ec),
+            static_cast<const Iterator&>(iter_));
+      }
+    }
+
+  //private:
+    basic_socket<Protocol, SocketService>& socket_;
+    Iterator iter_;
+    Iterator end_;
+    ComposedConnectHandler handler_;
+  };
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol,
+      typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void asio_handler_invoke(Function& function,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol,
+      typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void asio_handler_invoke(const Function& function,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline connect_op<Protocol, SocketService, Iterator,
+      ConnectCondition, ComposedConnectHandler>
+  make_connect_op(basic_socket<Protocol, SocketService>& sock,
+      const Iterator& begin, const Iterator& end,
+      const ConnectCondition& connect_condition,
+      ComposedConnectHandler handler)
+  {
+    return connect_op<Protocol, SocketService, Iterator,
+      ConnectCondition, ComposedConnectHandler>(
+        sock, begin, end, connect_condition, handler);
+  }
+} // namespace detail
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ComposedConnectHandler>
+inline void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, Iterator(),
+    detail::default_connect_condition(),
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+        boost::system::error_code(), 1);
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ComposedConnectHandler>
+inline void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, end,
+    detail::default_connect_condition(),
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+        boost::system::error_code(), 1);
+}
+
+template <typename Protocol, typename SocketService, typename Iterator,
+    typename ConnectCondition, typename ComposedConnectHandler>
+inline void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, ConnectCondition connect_condition,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, Iterator(), connect_condition,
+    BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+      boost::system::error_code(), 1);
+}
+
+template <typename Protocol, typename SocketService, typename Iterator,
+    typename ConnectCondition, typename ComposedConnectHandler>
+void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, end, connect_condition,
+    BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+      boost::system::error_code(), 1);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_CONNECT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/impl/error.ipp b/3rdParty/Boost/src/boost/asio/impl/error.ipp
index 7c045c0..11e7045 100644
--- a/3rdParty/Boost/src/boost/asio/impl/error.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/error.ipp
@@ -16,8 +16,6 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/cerrno.hpp>
-#include <boost/system/error_code.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -122,30 +120,6 @@ const boost::system::error_category& get_misc_category()
   return instance;
 }
 
-namespace detail {
-
-class ssl_category : public boost::system::error_category
-{
-public:
-  const char* name() const
-  {
-    return "asio.ssl";
-  }
-
-  std::string message(int) const
-  {
-    return "asio.ssl error";
-  }
-};
-
-} // namespace detail
-
-const boost::system::error_category& get_ssl_category()
-{
-  static detail::ssl_category instance;
-  return instance;
-}
-
 } // namespace error
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/impl/io_service.hpp b/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
index 152f983..dbdd294 100644
--- a/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
@@ -15,6 +15,7 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/service_registry.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -68,16 +69,25 @@ inline bool has_service(io_service& ios)
 namespace boost {
 namespace asio {
 
-template <typename Handler>
-inline void io_service::dispatch(Handler handler)
+template <typename CompletionHandler>
+inline void io_service::dispatch(
+    BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
 {
-  impl_.dispatch(handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a CompletionHandler.
+  BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+
+  impl_.dispatch(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
 }
 
-template <typename Handler>
-inline void io_service::post(Handler handler)
+template <typename CompletionHandler>
+inline void io_service::post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
 {
-  impl_.post(handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a CompletionHandler.
+  BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+
+  impl_.post(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
 }
 
 template <typename Handler>
@@ -108,21 +118,11 @@ inline io_service::work::~work()
   io_service_.impl_.work_finished();
 }
 
-inline boost::asio::io_service& io_service::work::io_service()
-{
-  return io_service_;
-}
-
 inline boost::asio::io_service& io_service::work::get_io_service()
 {
   return io_service_;
 }
 
-inline boost::asio::io_service& io_service::service::io_service()
-{
-  return owner_;
-}
-
 inline boost::asio::io_service& io_service::service::get_io_service()
 {
   return owner_;
diff --git a/3rdParty/Boost/src/boost/asio/impl/io_service.ipp b/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
index a0b34af..60ad28c 100644
--- a/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
@@ -108,11 +108,21 @@ void io_service::stop()
   impl_.stop();
 }
 
+bool io_service::stopped() const
+{
+  return impl_.stopped();
+}
+
 void io_service::reset()
 {
   impl_.reset();
 }
 
+void io_service::notify_fork(boost::asio::io_service::fork_event event)
+{
+  service_registry_->notify_fork(event);
+}
+
 io_service::service::service(boost::asio::io_service& owner)
   : owner_(owner),
     next_(0)
@@ -123,6 +133,10 @@ io_service::service::~service()
 {
 }
 
+void io_service::service::fork_service(boost::asio::io_service::fork_event)
+{
+}
+
 service_already_exists::service_already_exists()
   : std::logic_error("Service already exists.")
 {
diff --git a/3rdParty/Boost/src/boost/asio/impl/read.hpp b/3rdParty/Boost/src/boost/asio/impl/read.hpp
index 9fba190..8351810 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read.hpp
@@ -23,6 +23,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
@@ -58,10 +59,17 @@ inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read");
   return bytes_transferred;
 }
 
+template <typename SyncReadStream, typename MutableBufferSequence>
+inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return read(s, buffers, transfer_all(), ec);
+}
+
 template <typename SyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition>
 inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
@@ -69,7 +77,7 @@ inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read");
   return bytes_transferred;
 }
 
@@ -104,10 +112,18 @@ inline std::size_t read(SyncReadStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, b, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read");
   return bytes_transferred;
 }
 
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return read(s, b, transfer_all(), ec);
+}
+
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
 inline std::size_t read(SyncReadStream& s,
@@ -116,7 +132,7 @@ inline std::size_t read(SyncReadStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read");
   return bytes_transferred;
 }
 
@@ -131,15 +147,35 @@ namespace detail
   {
   public:
     read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
-        CompletionCondition completion_condition, ReadHandler handler)
+        CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_op(const read_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_op(read_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
     }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
@@ -150,7 +186,8 @@ namespace detail
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
-          stream_.async_read_some(buffers_, *this);
+          stream_.async_read_some(buffers_,
+              BOOST_ASIO_MOVE_CAST(read_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
@@ -181,17 +218,36 @@ namespace detail
   public:
     read_op(AsyncReadStream& stream,
         const boost::asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition,
-        ReadHandler handler)
+        CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_op(const read_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_op(read_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -202,8 +258,9 @@ namespace detail
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_read_some(boost::asio::buffer(
-                buffer_ + total_transferred_, n), *this);
+          stream_.async_read_some(
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(read_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
@@ -246,6 +303,17 @@ namespace detail
   template <typename Function, typename AsyncReadStream,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_op<AsyncReadStream, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_op<AsyncReadStream, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
@@ -253,25 +321,47 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncReadStream, typename MutableBufferSequence,
+      typename CompletionCondition, typename ReadHandler>
+  inline read_op<AsyncReadStream, MutableBufferSequence,
+      CompletionCondition, ReadHandler>
+  make_read_op(AsyncReadStream& s, const MutableBufferSequence& buffers,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_op<AsyncReadStream, MutableBufferSequence, CompletionCondition,
+      ReadHandler>(s, buffers, completion_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, ReadHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  detail::read_op<AsyncReadStream, MutableBufferSequence,
-    CompletionCondition, ReadHandler>(
-      s, buffers, completion_condition, handler)(
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_op(
+    s, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename ReadHandler>
 inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    ReadHandler handler)
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  async_read(s, buffers, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_op(
+    s, buffers, transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
@@ -286,16 +376,36 @@ namespace detail
   public:
     read_streambuf_op(AsyncReadStream& stream,
         basic_streambuf<Allocator>& streambuf,
-        CompletionCondition completion_condition, ReadHandler handler)
+        CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         streambuf_(streambuf),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_streambuf_op(const read_streambuf_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_streambuf_op(read_streambuf_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -307,7 +417,8 @@ namespace detail
         bytes_available = read_size_helper(streambuf_, max_size);
         for (;;)
         {
-          stream_.async_read_some(streambuf_.prepare(bytes_available), *this);
+          stream_.async_read_some(streambuf_.prepare(bytes_available),
+              BOOST_ASIO_MOVE_CAST(read_streambuf_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           streambuf_.commit(bytes_transferred);
@@ -350,6 +461,16 @@ namespace detail
 
   template <typename Function, typename AsyncReadStream,
       typename Allocator, typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_streambuf_op<AsyncReadStream, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream,
+      typename Allocator, typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_streambuf_op<AsyncReadStream, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
@@ -357,25 +478,48 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncReadStream, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline read_streambuf_op<AsyncReadStream, Allocator,
+      CompletionCondition, ReadHandler>
+  make_read_streambuf_op(
+      AsyncReadStream& s, boost::asio::basic_streambuf<Allocator>& b,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_streambuf_op<AsyncReadStream, Allocator, CompletionCondition,
+      ReadHandler>(s, b, completion_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
 inline void async_read(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, ReadHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  detail::read_streambuf_op<AsyncReadStream,
-    Allocator, CompletionCondition, ReadHandler>(
-      s, b, completion_condition, handler)(
-        boost::system::error_code(), 0, 1);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_streambuf_op(
+    s, b, completion_condition, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 inline void async_read(AsyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, ReadHandler handler)
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  async_read(s, b, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_streambuf_op(
+    s, b, transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
diff --git a/3rdParty/Boost/src/boost/asio/impl/read_at.hpp b/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
index dcf2c33..14fddc4 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
@@ -23,6 +23,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
@@ -62,10 +63,18 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_at(
       d, offset, buffers, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_at");
   return bytes_transferred;
 }
 
+template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return read_at(d, offset, buffers, transfer_all(), ec);
+}
+
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
@@ -75,7 +84,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_at(
       d, offset, buffers, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_at");
   return bytes_transferred;
 }
 
@@ -112,10 +121,18 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_at(
       d, offset, b, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_at");
   return bytes_transferred;
 }
 
+template <typename SyncRandomAccessReadDevice, typename Allocator>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return read_at(d, offset, b, transfer_all(), ec);
+}
+
 template <typename SyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
@@ -125,7 +142,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_at(
       d, offset, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_at");
   return bytes_transferred;
 }
 
@@ -142,16 +159,38 @@ namespace detail
   public:
     read_at_op(AsyncRandomAccessReadDevice& device,
         boost::uint64_t offset, const MutableBufferSequence& buffers,
-        CompletionCondition completion_condition, ReadHandler handler)
+        CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_op(const read_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_at_op(read_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
     }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
@@ -162,8 +201,8 @@ namespace detail
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
-          device_.async_read_some_at(
-              offset_ + total_transferred_, buffers_, *this);
+          device_.async_read_some_at(offset_ + total_transferred_,
+              buffers_, BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
@@ -195,17 +234,39 @@ namespace detail
   public:
     read_at_op(AsyncRandomAccessReadDevice& device,
         boost::uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition, ReadHandler handler)
+        CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_op(const read_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
     {
     }
 
+    read_at_op(read_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -217,7 +278,8 @@ namespace detail
         for (;;)
         {
           device_.async_read_some_at(offset_ + total_transferred_,
-              boost::asio::buffer(buffer_ + total_transferred_, n), *this);
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
@@ -263,6 +325,17 @@ namespace detail
   template <typename Function, typename AsyncRandomAccessReadDevice,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
@@ -270,17 +343,36 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline read_at_op<AsyncRandomAccessReadDevice,
+      MutableBufferSequence, CompletionCondition, ReadHandler>
+  make_read_at_op(AsyncRandomAccessReadDevice& d,
+      boost::uint64_t offset, const MutableBufferSequence& buffers,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_at_op<AsyncRandomAccessReadDevice,
+      MutableBufferSequence, CompletionCondition, ReadHandler>(
+        d, offset, buffers, completion_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 inline void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, ReadHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  detail::read_at_op<AsyncRandomAccessReadDevice,
-    MutableBufferSequence, CompletionCondition, ReadHandler>(
-      d, offset, buffers, completion_condition, handler)(
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_op(
+    d, offset, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
         boost::system::error_code(), 0, 1);
 }
 
@@ -288,9 +380,16 @@ template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename ReadHandler>
 inline void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, const MutableBufferSequence& buffers,
-    ReadHandler handler)
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  async_read_at(d, offset, buffers, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_op(
+    d, offset, buffers, transfer_all(),
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+        boost::system::error_code(), 0, 1);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
@@ -305,17 +404,39 @@ namespace detail
   public:
     read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
         boost::uint64_t offset, basic_streambuf<Allocator>& streambuf,
-        CompletionCondition completion_condition, ReadHandler handler)
+        CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         streambuf_(streambuf),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_streambuf_op(const read_at_streambuf_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
     {
     }
 
+    read_at_streambuf_op(read_at_streambuf_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -328,7 +449,8 @@ namespace detail
         for (;;)
         {
           device_.async_read_some_at(offset_ + total_transferred_,
-              streambuf_.prepare(bytes_available), *this);
+              streambuf_.prepare(bytes_available),
+              BOOST_ASIO_MOVE_CAST(read_at_streambuf_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           streambuf_.commit(bytes_transferred);
@@ -372,6 +494,16 @@ namespace detail
 
   template <typename Function, typename AsyncRandomAccessReadDevice,
       typename Allocator, typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessReadDevice,
+      typename Allocator, typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
@@ -379,17 +511,35 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncRandomAccessReadDevice, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline read_at_streambuf_op<AsyncRandomAccessReadDevice,
+      Allocator, CompletionCondition, ReadHandler>
+  make_read_at_streambuf_op(AsyncRandomAccessReadDevice& d,
+      boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_at_streambuf_op<AsyncRandomAccessReadDevice,
+      Allocator, CompletionCondition, ReadHandler>(
+        d, offset, b, completion_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
 inline void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, ReadHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
-    Allocator, CompletionCondition, ReadHandler>(
-      d, offset, b, completion_condition, handler)(
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_streambuf_op(
+    d, offset, b, completion_condition,
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
         boost::system::error_code(), 0, 1);
 }
 
@@ -397,9 +547,16 @@ template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename ReadHandler>
 inline void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    ReadHandler handler)
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  async_read_at(d, offset, b, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_streambuf_op(
+    d, offset, b, transfer_all(),
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+        boost::system::error_code(), 0, 1);
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
diff --git a/3rdParty/Boost/src/boost/asio/impl/read_until.hpp b/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
index 5eeb1bc..e27e0e2 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
@@ -25,6 +25,7 @@
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -38,7 +39,7 @@ inline std::size_t read_until(SyncReadStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, delim, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
@@ -56,11 +57,11 @@ std::size_t read_until(SyncReadStream& s,
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start = begin + search_position;
+    iterator start_pos = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
-    iterator iter = std::find(start, end, delim);
+    iterator iter = std::find(start_pos, end, delim);
     if (iter != end)
     {
       // Found a match. We're done.
@@ -94,7 +95,7 @@ inline std::size_t read_until(SyncReadStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, delim, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
@@ -147,12 +148,12 @@ std::size_t read_until(SyncReadStream& s,
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start = begin + search_position;
+    iterator start_pos = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
     std::pair<iterator, bool> result = detail::partial_search(
-        start, end, delim.begin(), delim.end());
+        start_pos, end, delim.begin(), delim.end());
     if (result.first != end)
     {
       if (result.second)
@@ -194,7 +195,7 @@ inline std::size_t read_until(SyncReadStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, expr, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
@@ -212,14 +213,14 @@ std::size_t read_until(SyncReadStream& s,
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start = begin + search_position;
+    iterator start_pos = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
     boost::match_results<iterator,
       typename std::vector<boost::sub_match<iterator> >::allocator_type>
         match_results;
-    if (regex_search(start, end, match_results, expr,
+    if (regex_search(start_pos, end, match_results, expr,
           boost::match_default | boost::match_partial))
     {
       if (match_results[0].matched)
@@ -270,11 +271,11 @@ std::size_t read_until(SyncReadStream& s,
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start = begin + search_position;
+    iterator start_pos = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
-    std::pair<iterator, bool> result = match_condition(start, end);
+    std::pair<iterator, bool> result = match_condition(start_pos, end);
     if (result.second)
     {
       // Full match. We're done.
@@ -314,7 +315,7 @@ inline std::size_t read_until(SyncReadStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, match_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
@@ -326,15 +327,35 @@ namespace detail
   public:
     read_until_delim_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        char delim, ReadHandler handler)
+        char delim, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
         search_position_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_until_delim_op(const read_until_delim_op& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        delim_(other.delim_),
+        search_position_(other.search_position_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_until_delim_op(read_until_delim_op&& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        delim_(other.delim_),
+        search_position_(other.search_position_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -352,11 +373,11 @@ namespace detail
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start = begin + search_position_;
+            iterator start_pos = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
-            iterator iter = std::find(start, end, delim_);
+            iterator iter = std::find(start_pos, end, delim_);
             if (iter != end)
             {
               // Found a match. We're done.
@@ -385,7 +406,8 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+              BOOST_ASIO_MOVE_CAST(read_until_delim_op)(*this));
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
@@ -432,6 +454,16 @@ namespace detail
 
   template <typename Function, typename AsyncReadStream, typename Allocator,
       typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_until_delim_op<AsyncReadStream,
+        Allocator, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream, typename Allocator,
+      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_delim_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
@@ -439,16 +471,30 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  inline read_until_delim_op<AsyncReadStream, Allocator, ReadHandler>
+  make_read_until_delim_op(AsyncReadStream& s,
+      boost::asio::basic_streambuf<Allocator>& b,
+      char delim, ReadHandler handler)
+  {
+    return read_until_delim_op<AsyncReadStream, Allocator, ReadHandler>(
+        s, b, delim, handler);
+  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, char delim, ReadHandler handler)
+    boost::asio::basic_streambuf<Allocator>& b, char delim,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  detail::read_until_delim_op<
-    AsyncReadStream, Allocator, ReadHandler>(
-      s, b, delim, handler)(
-        boost::system::error_code(), 0, 1);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_until_delim_op(
+    s, b, delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 namespace detail
@@ -459,15 +505,35 @@ namespace detail
   public:
     read_until_delim_string_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        const std::string& delim, ReadHandler handler)
+        const std::string& delim, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
         search_position_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_until_delim_string_op(const read_until_delim_string_op& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        delim_(other.delim_),
+        search_position_(other.search_position_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_until_delim_string_op(read_until_delim_string_op&& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        delim_(BOOST_ASIO_MOVE_CAST(std::string)(other.delim_)),
+        search_position_(other.search_position_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -485,12 +551,12 @@ namespace detail
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start = begin + search_position_;
+            iterator start_pos = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
             std::pair<iterator, bool> result = detail::partial_search(
-                start, end, delim_.begin(), delim_.end());
+                start_pos, end, delim_.begin(), delim_.end());
             if (result.first != end && result.second)
             {
               // Full match. We're done.
@@ -529,7 +595,8 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+              BOOST_ASIO_MOVE_CAST(read_until_delim_string_op)(*this));
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
@@ -576,6 +643,16 @@ namespace detail
 
   template <typename Function, typename AsyncReadStream,
       typename Allocator, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_until_delim_string_op<AsyncReadStream,
+        Allocator, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream,
+      typename Allocator, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_delim_string_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
@@ -583,17 +660,30 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  inline read_until_delim_string_op<AsyncReadStream, Allocator, ReadHandler>
+  make_read_until_delim_string_op(AsyncReadStream& s,
+      boost::asio::basic_streambuf<Allocator>& b,
+      const std::string& delim, ReadHandler handler)
+  {
+    return read_until_delim_string_op<AsyncReadStream, Allocator, ReadHandler>(
+        s, b, delim, handler);
+  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
-    ReadHandler handler)
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  detail::read_until_delim_string_op<
-    AsyncReadStream, Allocator, ReadHandler>(
-      s, b, delim, handler)(
-        boost::system::error_code(), 0, 1);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_until_delim_string_op(
+    s, b, delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 namespace detail
@@ -605,15 +695,35 @@ namespace detail
   public:
     read_until_expr_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        const boost::regex& expr, ReadHandler handler)
+        const boost::regex& expr, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         expr_(expr),
         search_position_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_until_expr_op(const read_until_expr_op& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        expr_(other.expr_),
+        search_position_(other.search_position_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_until_expr_op(read_until_expr_op&& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        expr_(other.expr_),
+        search_position_(other.search_position_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -631,14 +741,14 @@ namespace detail
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start = begin + search_position_;
+            iterator start_pos = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
             boost::match_results<iterator,
               typename std::vector<boost::sub_match<iterator> >::allocator_type>
                 match_results;
-            bool match = regex_search(start, end, match_results, expr_,
+            bool match = regex_search(start_pos, end, match_results, expr_,
                 boost::match_default | boost::match_partial);
             if (match && match_results[0].matched)
             {
@@ -678,7 +788,8 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+              BOOST_ASIO_MOVE_CAST(read_until_expr_op)(*this));
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
@@ -727,6 +838,16 @@ namespace detail
 
   template <typename Function, typename AsyncReadStream, typename Allocator,
       typename RegEx, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_until_expr_op<AsyncReadStream,
+        Allocator, RegEx, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream, typename Allocator,
+      typename RegEx, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_expr_op<AsyncReadStream,
         Allocator, RegEx, ReadHandler>* this_handler)
@@ -734,17 +855,31 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncReadStream, typename Allocator,
+      typename RegEx, typename ReadHandler>
+  inline read_until_expr_op<AsyncReadStream, Allocator, RegEx, ReadHandler>
+  make_read_until_expr_op(AsyncReadStream& s,
+      boost::asio::basic_streambuf<Allocator>& b,
+      const boost::regex& expr, ReadHandler handler)
+  {
+    return read_until_expr_op<AsyncReadStream, Allocator, RegEx, ReadHandler>(
+        s, b, expr, handler);
+  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    ReadHandler handler)
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
-  detail::read_until_expr_op<AsyncReadStream,
-    Allocator, boost::regex, ReadHandler>(
-      s, b, expr, handler)(
-        boost::system::error_code(), 0, 1);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_until_expr_op(
+    s, b, expr, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 namespace detail
@@ -756,15 +891,35 @@ namespace detail
   public:
     read_until_match_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        MatchCondition match_condition, ReadHandler handler)
+        MatchCondition match_condition, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         match_condition_(match_condition),
         search_position_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_until_match_op(const read_until_match_op& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        match_condition_(other.match_condition_),
+        search_position_(other.search_position_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_until_match_op(read_until_match_op&& other)
+      : stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        match_condition_(other.match_condition_),
+        search_position_(other.search_position_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -782,11 +937,11 @@ namespace detail
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start = begin + search_position_;
+            iterator start_pos = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
-            std::pair<iterator, bool> result = match_condition_(start, end);
+            std::pair<iterator, bool> result = match_condition_(start_pos, end);
             if (result.second)
             {
               // Full match. We're done.
@@ -825,7 +980,8 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+              BOOST_ASIO_MOVE_CAST(read_until_match_op)(*this));
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
@@ -874,6 +1030,16 @@ namespace detail
 
   template <typename Function, typename AsyncReadStream, typename Allocator,
       typename MatchCondition, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_until_match_op<AsyncReadStream,
+        Allocator, MatchCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream, typename Allocator,
+      typename MatchCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_match_op<AsyncReadStream,
         Allocator, MatchCondition, ReadHandler>* this_handler)
@@ -881,19 +1047,35 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncReadStream, typename Allocator,
+      typename MatchCondition, typename ReadHandler>
+  inline read_until_match_op<AsyncReadStream, Allocator,
+      MatchCondition, ReadHandler>
+  make_read_until_match_op(AsyncReadStream& s,
+      boost::asio::basic_streambuf<Allocator>& b,
+      MatchCondition match_condition, ReadHandler handler)
+  {
+    return read_until_match_op<AsyncReadStream,
+      Allocator, MatchCondition, ReadHandler>(
+        s, b, match_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncReadStream, typename Allocator,
     typename MatchCondition, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, ReadHandler handler,
+    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
     typename boost::enable_if<is_match_condition<MatchCondition> >::type*)
 {
-  detail::read_until_match_op<
-    AsyncReadStream, Allocator, MatchCondition, ReadHandler>(
-      s, b, match_condition, handler)(
-        boost::system::error_code(), 0, 1);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_until_match_op(
+    s, b, match_condition, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/impl/write.hpp b/3rdParty/Boost/src/boost/asio/impl/write.hpp
index ae420bc..2c5c595 100644
--- a/3rdParty/Boost/src/boost/asio/impl/write.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/write.hpp
@@ -22,6 +22,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -56,10 +57,17 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
+template <typename SyncWriteStream, typename ConstBufferSequence>
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return write(s, buffers, transfer_all(), ec);
+}
+
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
@@ -67,7 +75,7 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
@@ -90,10 +98,18 @@ inline std::size_t write(SyncWriteStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, b, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
+template <typename SyncWriteStream, typename Allocator>
+inline std::size_t write(SyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return write(s, b, transfer_all(), ec);
+}
+
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s,
@@ -102,7 +118,7 @@ inline std::size_t write(SyncWriteStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
@@ -117,15 +133,35 @@ namespace detail
   {
   public:
     write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
-        CompletionCondition completion_condition, WriteHandler handler)
+        CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
     }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
@@ -136,7 +172,8 @@ namespace detail
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
-          stream_.async_write_some(buffers_, *this);
+          stream_.async_write_some(buffers_,
+              BOOST_ASIO_MOVE_CAST(write_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
@@ -168,16 +205,36 @@ namespace detail
     write_op(AsyncWriteStream& stream,
         const boost::asio::mutable_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler handler)
+        WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -188,8 +245,9 @@ namespace detail
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_write_some(boost::asio::buffer(
-                buffer_ + total_transferred_, n), *this);
+          stream_.async_write_some(
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
@@ -219,16 +277,36 @@ namespace detail
     write_op(AsyncWriteStream& stream,
         const boost::asio::const_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler handler)
+        WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
     {
     }
 
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -239,8 +317,9 @@ namespace detail
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_write_some(boost::asio::buffer(
-                buffer_ + total_transferred_, n), *this);
+          stream_.async_write_some(
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
@@ -283,6 +362,17 @@ namespace detail
   template <typename Function, typename AsyncWriteStream,
       typename ConstBufferSequence, typename CompletionCondition,
       typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_op<AsyncWriteStream, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncWriteStream,
+      typename ConstBufferSequence, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
       write_op<AsyncWriteStream, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
@@ -290,43 +380,78 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline write_op<AsyncWriteStream, ConstBufferSequence,
+      CompletionCondition, WriteHandler>
+  make_write_op(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+      CompletionCondition completion_condition, WriteHandler handler)
+  {
+    return write_op<AsyncWriteStream, ConstBufferSequence, CompletionCondition,
+      WriteHandler>(s, buffers, completion_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
   typename CompletionCondition, typename WriteHandler>
 inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, WriteHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  detail::write_op<AsyncWriteStream, ConstBufferSequence,
-    CompletionCondition, WriteHandler>(
-      s, buffers, completion_condition, handler)(
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_op(
+    s, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename WriteHandler>
 inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    WriteHandler handler)
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  async_write(s, buffers, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_op(
+    s, buffers, transfer_all(), BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
-  template <typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   class write_streambuf_handler
   {
   public:
     write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler handler)
+        WriteHandler& handler)
       : streambuf_(streambuf),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_streambuf_handler(const write_streambuf_handler& other)
+      : streambuf_(other.streambuf_),
+        handler_(other.handler_)
     {
     }
 
+    write_streambuf_handler(write_streambuf_handler&& other)
+      : streambuf_(other.streambuf_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         const std::size_t bytes_transferred)
     {
@@ -339,53 +464,75 @@ namespace detail
     WriteHandler handler_;
   };
 
-  template <typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_streambuf_handler<AsyncWriteStream,
-        Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_streambuf_handler<AsyncWriteStream,
-        Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Function, typename Allocator, typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Allocator, typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_streambuf_handler<AsyncWriteStream,
-        Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename Allocator, typename WriteHandler>
+  inline write_streambuf_handler<Allocator, WriteHandler>
+  make_write_streambuf_handler(
+      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
+  {
+    return write_streambuf_handler<Allocator, WriteHandler>(b, handler);
+  }
 } // namespace detail
 
 template <typename AsyncWriteStream, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
 inline void async_write(AsyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, WriteHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
   async_write(s, b.data(), completion_condition,
-      detail::write_streambuf_handler<
-        AsyncWriteStream, Allocator, WriteHandler>(b, handler));
+      detail::make_write_streambuf_handler(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
 }
 
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
 inline void async_write(AsyncWriteStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  async_write(s, b, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  async_write(s, b.data(), transfer_all(),
+      detail::make_write_streambuf_handler(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
diff --git a/3rdParty/Boost/src/boost/asio/impl/write_at.hpp b/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
index 39dc1af..b1ac94c 100644
--- a/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
@@ -22,6 +22,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -60,10 +61,18 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
   boost::system::error_code ec;
   std::size_t bytes_transferred = write_at(
       d, offset, buffers, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write_at");
   return bytes_transferred;
 }
 
+template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return write_at(d, offset, buffers, transfer_all(), ec);
+}
+
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
@@ -73,7 +82,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
   boost::system::error_code ec;
   std::size_t bytes_transferred = write_at(
       d, offset, buffers, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write_at");
   return bytes_transferred;
 }
 
@@ -97,10 +106,18 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write_at(d, offset, b, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write_at");
   return bytes_transferred;
 }
 
+template <typename SyncRandomAccessWriteDevice, typename Allocator>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return write_at(d, offset, b, transfer_all(), ec);
+}
+
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
@@ -110,7 +127,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
   boost::system::error_code ec;
   std::size_t bytes_transferred = write_at(
       d, offset, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write_at");
   return bytes_transferred;
 }
 
@@ -126,16 +143,38 @@ namespace detail
   public:
     write_at_op(AsyncRandomAccessWriteDevice& device,
         boost::uint64_t offset, const ConstBufferSequence& buffers,
-        CompletionCondition completion_condition, WriteHandler handler)
+        CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
     }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
@@ -147,7 +186,8 @@ namespace detail
         for (;;)
         {
           device_.async_write_some_at(
-              offset_ + total_transferred_, buffers_, *this);
+              offset_ + total_transferred_, buffers_,
+              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
@@ -180,17 +220,39 @@ namespace detail
     write_at_op(AsyncRandomAccessWriteDevice& device,
         boost::uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler handler)
+        WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -202,7 +264,8 @@ namespace detail
         for (;;)
         {
           device_.async_write_some_at(offset_ + total_transferred_,
-              boost::asio::buffer(buffer_ + total_transferred_, n), *this);
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
@@ -233,17 +296,39 @@ namespace detail
     write_at_op(AsyncRandomAccessWriteDevice& device,
         boost::uint64_t offset, const boost::asio::const_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler handler)
+        WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
@@ -255,7 +340,8 @@ namespace detail
         for (;;)
         {
           device_.async_write_some_at(offset_ + total_transferred_,
-              boost::asio::buffer(buffer_ + total_transferred_, n), *this);
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
@@ -299,6 +385,17 @@ namespace detail
   template <typename Function, typename AsyncRandomAccessWriteDevice,
       typename ConstBufferSequence, typename CompletionCondition,
       typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessWriteDevice,
+      typename ConstBufferSequence, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
@@ -306,17 +403,35 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline write_at_op<AsyncRandomAccessWriteDevice,
+      ConstBufferSequence, CompletionCondition, WriteHandler>
+  make_write_at_op(AsyncRandomAccessWriteDevice& d,
+      boost::uint64_t offset, const ConstBufferSequence& buffers,
+      CompletionCondition completion_condition, WriteHandler handler)
+  {
+    return write_at_op<AsyncRandomAccessWriteDevice,
+      ConstBufferSequence, CompletionCondition, WriteHandler>(
+        d, offset, buffers, completion_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
 inline void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, WriteHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  detail::write_at_op<AsyncRandomAccessWriteDevice,
-    ConstBufferSequence, CompletionCondition, WriteHandler>(
-      d, offset, buffers, completion_condition, handler)(
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_at_op(
+    d, offset, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
         boost::system::error_code(), 0, 1);
 }
 
@@ -324,28 +439,48 @@ template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename WriteHandler>
 inline void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, const ConstBufferSequence& buffers,
-    WriteHandler handler)
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  async_write_at(d, offset, buffers, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_at_op(
+    d, offset, buffers, transfer_all(),
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
+        boost::system::error_code(), 0, 1);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
-  template <typename AsyncRandomAccessWriteDevice,
-      typename Allocator, typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   class write_at_streambuf_op
   {
   public:
     write_at_streambuf_op(
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler handler)
+        WriteHandler& handler)
       : streambuf_(streambuf),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_streambuf_op(const write_at_streambuf_op& other)
+      : streambuf_(other.streambuf_),
+        handler_(other.handler_)
     {
     }
 
+    write_at_streambuf_op(write_at_streambuf_op&& other)
+      : streambuf_(other.streambuf_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
     void operator()(const boost::system::error_code& ec,
         const std::size_t bytes_transferred)
     {
@@ -358,55 +493,76 @@ namespace detail
     WriteHandler handler_;
   };
 
-  template <typename AsyncRandomAccessWriteDevice, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_at_streambuf_op<AsyncRandomAccessWriteDevice,
-        Allocator, WriteHandler>* this_handler)
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncRandomAccessWriteDevice, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_at_streambuf_op<AsyncRandomAccessWriteDevice,
-        Allocator, WriteHandler>* this_handler)
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncRandomAccessWriteDevice,
-      typename Allocator, typename WriteHandler>
+  template <typename Function, typename Allocator, typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Allocator, typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_at_streambuf_op<AsyncRandomAccessWriteDevice,
-        Allocator, WriteHandler>* this_handler)
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename Allocator, typename WriteHandler>
+  inline write_at_streambuf_op<Allocator, WriteHandler>
+  make_write_at_streambuf_op(
+      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
+  {
+    return write_at_streambuf_op<Allocator, WriteHandler>(b, handler);
+  }
 } // namespace detail
 
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
 inline void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, WriteHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
   async_write_at(d, offset, b.data(), completion_condition,
-      detail::write_at_streambuf_op<
-        AsyncRandomAccessWriteDevice, Allocator, WriteHandler>(b, handler));
+      detail::make_write_at_streambuf_op(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
 }
 
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename WriteHandler>
 inline void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    WriteHandler handler)
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  async_write_at(d, offset, b, transfer_all(), handler);
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  async_write_at(d, offset, b.data(), transfer_all(),
+      detail::make_write_at_streambuf_op(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
diff --git a/3rdParty/Boost/src/boost/asio/io_service.hpp b/3rdParty/Boost/src/boost/asio/io_service.hpp
index a6a27fa..e1ed0bd 100644
--- a/3rdParty/Boost/src/boost/asio/io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/io_service.hpp
@@ -68,9 +68,12 @@ namespace detail { typedef task_io_service io_service_impl; }
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe, with the exception that calling reset() while
- * there are unfinished run(), run_one(), poll() or poll_one() calls results in
- * undefined behaviour.
+ * @e Shared @e objects: Safe, with the specific exceptions of the reset() and
+ * notify_fork() functions. Calling reset() while there are unfinished run(),
+ * run_one(), poll() or poll_one() calls results in undefined behaviour. The
+ * notify_fork() function should not be called while any io_service function,
+ * or any function on an I/O object that is associated with the io_service, is
+ * being called in another thread.
  *
  * @par Concepts:
  * Dispatcher.
@@ -256,8 +259,10 @@ public:
    * waiting in the pool are equivalent and the io_service may choose any one
    * of them to invoke a handler.
    *
-   * The run() function may be safely called again once it has completed only
-   * after a call to reset().
+   * A normal exit from the run() function implies that the io_service object
+   * is stopped (the stopped() function returns @c true). Subsequent calls to
+   * run(), run_one(), poll() or poll_one() will return immediately unless there
+   * is a prior call to reset().
    *
    * @return The number of handlers that were executed.
    *
@@ -282,8 +287,10 @@ public:
    * waiting in the pool are equivalent and the io_service may choose any one
    * of them to invoke a handler.
    *
-   * The run() function may be safely called again once it has completed only
-   * after a call to reset().
+   * A normal exit from the run() function implies that the io_service object
+   * is stopped (the stopped() function returns @c true). Subsequent calls to
+   * run(), run_one(), poll() or poll_one() will return immediately unless there
+   * is a prior call to reset().
    *
    * @param ec Set to indicate what error occurred, if any.
    *
@@ -304,7 +311,11 @@ public:
    * The run_one() function blocks until one handler has been dispatched, or
    * until the io_service has been stopped.
    *
-   * @return The number of handlers that were executed.
+   * @return The number of handlers that were executed. A zero return value
+   * implies that the io_service object is stopped (the stopped() function
+   * returns @c true). Subsequent calls to run(), run_one(), poll() or
+   * poll_one() will return immediately unless there is a prior call to
+   * reset().
    *
    * @throws boost::system::system_error Thrown on failure.
    */
@@ -316,7 +327,11 @@ public:
    * The run_one() function blocks until one handler has been dispatched, or
    * until the io_service has been stopped.
    *
-   * @param ec Set to indicate what error occurred, if any.
+   * @return The number of handlers that were executed. A zero return value
+   * implies that the io_service object is stopped (the stopped() function
+   * returns @c true). Subsequent calls to run(), run_one(), poll() or
+   * poll_one() will return immediately unless there is a prior call to
+   * reset().
    *
    * @return The number of handlers that were executed.
    */
@@ -379,13 +394,25 @@ public:
    */
   BOOST_ASIO_DECL void stop();
 
+  /// Determine whether the io_service object has been stopped.
+  /**
+   * This function is used to determine whether an io_service object has been
+   * stopped, either through an explicit call to stop(), or due to running out
+   * of work. When an io_service object is stopped, calls to run(), run_one(),
+   * poll() or poll_one() will return immediately without invoking any
+   * handlers.
+   *
+   * @return @c true if the io_service object is stopped, otherwise @c false.
+   */
+  BOOST_ASIO_DECL bool stopped() const;
+
   /// Reset the io_service in preparation for a subsequent run() invocation.
   /**
    * This function must be called prior to any second or later set of
    * invocations of the run(), run_one(), poll() or poll_one() functions when a
    * previous invocation of these functions returned due to the io_service
-   * being stopped or running out of work. This function allows the io_service
-   * to reset any internal state, such as a "stopped" flag.
+   * being stopped or running out of work. After a call to reset(), the
+   * io_service object's stopped() function will return @c false.
    *
    * This function must not be called while there are any unfinished calls to
    * the run(), run_one(), poll() or poll_one() functions.
@@ -414,7 +441,7 @@ public:
    * throws an exception.
    */
   template <typename CompletionHandler>
-  void dispatch(CompletionHandler handler);
+  void dispatch(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
 
   /// Request the io_service to invoke the given handler and return immediately.
   /**
@@ -439,7 +466,7 @@ public:
    * throws an exception.
    */
   template <typename CompletionHandler>
-  void post(CompletionHandler handler);
+  void post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
 
   /// Create a new handler that automatically dispatches the wrapped handler
   /// on the io_service.
@@ -471,6 +498,61 @@ public:
 #endif
   wrap(Handler handler);
 
+  /// Fork-related event notifications.
+  enum fork_event
+  {
+    /// Notify the io_service that the process is about to fork.
+    fork_prepare,
+
+    /// Notify the io_service that the process has forked and is the parent.
+    fork_parent,
+
+    /// Notify the io_service that the process has forked and is the child.
+    fork_child
+  };
+
+  /// Notify the io_service of a fork-related event.
+  /**
+   * This function is used to inform the io_service that the process is about
+   * to fork, or has just forked. This allows the io_service, and the services
+   * it contains, to perform any necessary housekeeping to ensure correct
+   * operation following a fork.
+   *
+   * This function must not be called while any other io_service function, or
+   * any function on an I/O object associated with the io_service, is being
+   * called in another thread. It is, however, safe to call this function from
+   * within a completion handler, provided no other thread is accessing the
+   * io_service.
+   *
+   * @param event A fork-related event.
+   *
+   * @throws boost::system::system_error Thrown on failure. If the notification
+   * fails the io_service object should no longer be used and should be
+   * destroyed.
+   *
+   * @par Example
+   * The following code illustrates how to incorporate the notify_fork()
+   * function:
+   * @code my_io_service.notify_fork(boost::asio::io_service::fork_prepare);
+   * if (fork() == 0)
+   * {
+   *   // This is the child process.
+   *   my_io_service.notify_fork(boost::asio::io_service::fork_child);
+   * }
+   * else
+   * {
+   *   // This is the parent process.
+   *   my_io_service.notify_fork(boost::asio::io_service::fork_parent);
+   * } @endcode
+   *
+   * @note For each service object @c svc in the io_service set, performs
+   * <tt>svc->fork_service();</tt>. When processing the fork_prepare event,
+   * services are visited in reverse order of the beginning of service object
+   * lifetime. Otherwise, services are visited in order of the beginning of
+   * service object lifetime.
+   */
+  BOOST_ASIO_DECL void notify_fork(boost::asio::io_service::fork_event event);
+
   /// Obtain the service object corresponding to the given type.
   /**
    * This function is used to locate a service object that corresponds to
@@ -569,10 +651,6 @@ public:
    */
   ~work();
 
-  /// (Deprecated: use get_io_service().) Get the io_service associated with the
-  /// work.
-  boost::asio::io_service& io_service();
-
   /// Get the io_service associated with the work.
   boost::asio::io_service& get_io_service();
 
@@ -598,10 +676,6 @@ class io_service::service
   : private noncopyable
 {
 public:
-  /// (Deprecated: use get_io_service().) Get the io_service object that owns
-  /// the service.
-  boost::asio::io_service& io_service();
-
   /// Get the io_service object that owns the service.
   boost::asio::io_service& get_io_service();
 
@@ -619,6 +693,15 @@ private:
   /// Destroy all user-defined handler objects owned by the service.
   virtual void shutdown_service() = 0;
 
+  /// Handle notification of a fork-related event to perform any necessary
+  /// housekeeping.
+  /**
+   * This function is not a pure virtual so that services only have to
+   * implement it if necessary. The default implementation does nothing.
+   */
+  BOOST_ASIO_DECL virtual void fork_service(
+      boost::asio::io_service::fork_event event);
+
   friend class boost::asio::detail::service_registry;
   struct key
   {
diff --git a/3rdParty/Boost/src/boost/asio/ip/address.hpp b/3rdParty/Boost/src/boost/asio/ip/address.hpp
index 4ecae7a..f2960ee 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address.hpp
@@ -55,9 +55,19 @@ public:
   /// 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);
@@ -108,6 +118,15 @@ public:
   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);
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp b/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
index 5728a17..d4460f0 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
@@ -17,7 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <string>
-#include <boost/array.hpp>
+#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>
@@ -45,7 +45,15 @@ class address_v4
 {
 public:
   /// The type used to represent an address as an array of bytes.
-  typedef boost::array<unsigned char, 4> bytes_type;
+  /**
+   * @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()
@@ -65,6 +73,14 @@ public:
   {
   }
 
+#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)
   {
@@ -72,6 +88,15 @@ public:
     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;
 
@@ -98,6 +123,12 @@ public:
   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;
 
@@ -149,19 +180,19 @@ public:
   /// Obtain an address object that represents any address.
   static address_v4 any()
   {
-    return address_v4(static_cast<unsigned long>(INADDR_ANY));
+    return address_v4();
   }
 
   /// Obtain an address object that represents the loopback address.
   static address_v4 loopback()
   {
-    return address_v4(static_cast<unsigned long>(INADDR_LOOPBACK));
+    return address_v4(0x7F000001);
   }
 
   /// Obtain an address object that represents the broadcast address.
   static address_v4 broadcast()
   {
-    return address_v4(static_cast<unsigned long>(INADDR_BROADCAST));
+    return address_v4(0xFFFFFFFF);
   }
 
   /// Obtain an address object that represents the broadcast address that
diff --git a/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp b/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
index 9155bea..d2420c6 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
@@ -17,7 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <string>
-#include <boost/array.hpp>
+#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>
@@ -46,7 +46,15 @@ class address_v6
 {
 public:
   /// The type used to represent an address as an array of bytes.
-  typedef boost::array<unsigned char, 16> bytes_type;
+  /**
+   * @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();
@@ -58,9 +66,19 @@ public:
   /// 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.
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
index 0047adc..cabc0dd 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
@@ -78,8 +78,9 @@ public:
    * boost::asio::ip::udp::endpoint ep(boost::asio::ip::udp::v6(), 9876);
    * @endcode
    */
-  basic_endpoint(const InternetProtocol& protocol, unsigned short port_num)
-    : impl_(protocol.family(), port_num)
+  basic_endpoint(const InternetProtocol& internet_protocol,
+      unsigned short port_num)
+    : impl_(internet_protocol.family(), port_num)
   {
   }
 
@@ -97,6 +98,14 @@ public:
   {
   }
 
+#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)
   {
@@ -104,6 +113,15 @@ public:
     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
   {
@@ -131,9 +149,9 @@ public:
   }
 
   /// Set the underlying size of the endpoint in the native type.
-  void resize(std::size_t size)
+  void resize(std::size_t new_size)
   {
-    impl_.resize(size);
+    impl_.resize(new_size);
   }
 
   /// Get the capacity of the endpoint in the native type.
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
index f27515a..7ddfed2 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
@@ -17,6 +17,7 @@
 
 #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>
@@ -99,7 +100,7 @@ public:
   {
     boost::system::error_code ec;
     iterator i = this->service.resolve(this->implementation, q, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "resolve");
     return i;
   }
 
@@ -152,9 +153,16 @@ public:
    * the handler.
    */
   template <typename ResolveHandler>
-  void async_resolve(const query& q, ResolveHandler handler)
+  void async_resolve(const query& q,
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    return this->service.async_resolve(this->implementation, q, 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.
@@ -179,7 +187,7 @@ public:
   {
     boost::system::error_code ec;
     iterator i = this->service.resolve(this->implementation, e, ec);
-    boost::asio::detail::throw_error(ec);
+    boost::asio::detail::throw_error(ec, "resolve");
     return i;
   }
 
@@ -236,9 +244,16 @@ public:
    * the handler.
    */
   template <typename ResolveHandler>
-  void async_resolve(const endpoint_type& e, ResolveHandler handler)
+  void async_resolve(const endpoint_type& e,
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    return this->service.async_resolve(this->implementation, e, 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));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
index 980b488..d34de64 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
@@ -49,11 +49,11 @@ public:
   }
 
   /// Construct with specified endpoint, host name and service name.
-  basic_resolver_entry(const endpoint_type& endpoint,
-      const std::string& host_name, const std::string& service_name)
-    : endpoint_(endpoint),
-      host_name_(host_name),
-      service_name_(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)
   {
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
index 465c278..93be37c 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
@@ -16,8 +16,9 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/iterator.hpp>
+#include <cstddef>
 #include <cstring>
+#include <iterator>
 #include <string>
 #include <vector>
 #include <boost/asio/detail/shared_ptr.hpp>
@@ -45,15 +46,23 @@ namespace ip {
  */
 template <typename InternetProtocol>
 class basic_resolver_iterator
-#if defined(GENERATING_DOCUMENTATION)
-  : public std::iterator<
-#else // defined(GENERATING_DOCUMENTATION)
-  : public boost::iterator<
-#endif // defined(GENERATING_DOCUMENTATION)
-      std::forward_iterator_tag,
-      const basic_resolver_entry<InternetProtocol> >
 {
 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)
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
index 8fd63bc..11753dd 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
@@ -48,8 +48,8 @@ public:
    * This constructor is typically used to perform name resolution for local
    * service binding.
    *
-   * @param service_name A string identifying the requested service. This may
-   * be a descriptive name or a numeric string corresponding to a port number.
+   * @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
@@ -60,11 +60,11 @@ public:
    * <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_name,
+  basic_resolver_query(const std::string& service,
       resolver_query_base::flags resolve_flags = passive | address_configured)
     : hints_(),
       host_name_(),
-      service_name_(service_name)
+      service_name_(service)
   {
     typename InternetProtocol::endpoint endpoint;
     hints_.ai_flags = static_cast<int>(resolve_flags);
@@ -85,8 +85,8 @@ public:
    * @param protocol A protocol object, normally representing either the IPv4 or
    * IPv6 version of an internet protocol.
    *
-   * @param service_name A string identifying the requested service. This may
-   * be a descriptive name or a numeric string corresponding to a port number.
+   * @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
@@ -98,11 +98,11 @@ public:
    * may use additional locations when resolving service names.
    */
   basic_resolver_query(const protocol_type& protocol,
-      const std::string& service_name,
+      const std::string& service,
       resolver_query_base::flags resolve_flags = passive | address_configured)
     : hints_(),
       host_name_(),
-      service_name_(service_name)
+      service_name_(service)
   {
     hints_.ai_flags = static_cast<int>(resolve_flags);
     hints_.ai_family = protocol.family();
@@ -119,16 +119,16 @@ public:
    * This constructor is typically used to perform name resolution for
    * communication with remote hosts.
    *
-   * @param host_name 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 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_name 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 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
@@ -145,12 +145,11 @@ public:
    * <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_name,
-      const std::string& service_name,
+  basic_resolver_query(const std::string& host, const std::string& service,
       resolver_query_base::flags resolve_flags = address_configured)
     : hints_(),
-      host_name_(host_name),
-      service_name_(service_name)
+      host_name_(host),
+      service_name_(service)
   {
     typename InternetProtocol::endpoint endpoint;
     hints_.ai_flags = static_cast<int>(resolve_flags);
@@ -171,16 +170,16 @@ public:
    * @param protocol A protocol object, normally representing either the IPv4 or
    * IPv6 version of an internet protocol.
    *
-   * @param host_name 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 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_name 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 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
@@ -198,11 +197,11 @@ public:
    * may use additional locations when resolving service names.
    */
   basic_resolver_query(const protocol_type& protocol,
-      const std::string& host_name, const std::string& service_name,
+      const std::string& host, const std::string& service,
       resolver_query_base::flags resolve_flags = address_configured)
     : hints_(),
-      host_name_(host_name),
-      service_name_(service_name)
+      host_name_(host),
+      service_name_(service)
   {
     hints_.ai_flags = static_cast<int>(resolve_flags);
     hints_.ai_family = protocol.family();
diff --git a/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp b/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
index fe95a00..f01f616 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
@@ -78,12 +78,12 @@ public:
   }
 
   // Set the underlying size of the endpoint in the native type.
-  BOOST_ASIO_DECL void resize(std::size_t size);
+  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(boost::asio::detail::sockaddr_storage_type);
+    return sizeof(data_);
   }
 
   // Get the port associated with the endpoint.
@@ -122,7 +122,6 @@ private:
   union data_union
   {
     boost::asio::detail::socket_addr_type base;
-    boost::asio::detail::sockaddr_storage_type storage;
     boost::asio::detail::sockaddr_in4_type v4;
     boost::asio::detail::sockaddr_in6_type v6;
   } data_;
diff --git a/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp b/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
index 0443d38..e70c645 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
@@ -57,8 +57,14 @@ endpoint::endpoint(int family, unsigned short port_num)
     data_.v6.sin6_port =
       boost::asio::detail::socket_ops::host_to_network_short(port_num);
     data_.v6.sin6_flowinfo = 0;
-    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
-    data_.v6.sin6_addr = tmp_addr;
+    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;
   }
 }
@@ -85,14 +91,14 @@ endpoint::endpoint(const boost::asio::ip::address& addr,
     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.elems, 16);
+    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 size)
+void endpoint::resize(std::size_t new_size)
 {
-  if (size > sizeof(boost::asio::detail::sockaddr_storage_type))
+  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);
@@ -139,7 +145,11 @@ boost::asio::ip::address endpoint::address() const
   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);
   }
 }
diff --git a/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp b/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
index 6fde8c3..e8c6aa7 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
@@ -18,6 +18,7 @@
 #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>
@@ -385,35 +386,22 @@ class multicast_request
 public:
   // Default constructor.
   multicast_request()
+    : ipv4_value_(), // Zero-initialisation gives the "any" address.
+      ipv6_value_() // Zero-initialisation gives the "any" address.
   {
-    ipv4_value_.imr_multiaddr.s_addr =
-      boost::asio::detail::socket_ops::host_to_network_long(
-          boost::asio::ip::address_v4::any().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());
-
-    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
-    ipv6_value_.ipv6mr_multiaddr = tmp_addr;
-    ipv6_value_.ipv6mr_interface = 0;
   }
 
   // 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())
     {
-      ipv4_value_.imr_multiaddr.s_addr =
-        boost::asio::detail::socket_ops::host_to_network_long(
-            boost::asio::ip::address_v4::any().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());
-
       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.elems, 16);
+      memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
       ipv6_value_.ipv6mr_interface = 0;
     }
     else
@@ -424,10 +412,6 @@ public:
       ipv4_value_.imr_interface.s_addr =
         boost::asio::detail::socket_ops::host_to_network_long(
             boost::asio::ip::address_v4::any().to_ulong());
-
-      boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
-      ipv6_value_.ipv6mr_multiaddr = tmp_addr;
-      ipv6_value_.ipv6mr_interface = 0;
     }
   }
 
@@ -436,6 +420,7 @@ public:
       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(
@@ -443,28 +428,18 @@ public:
     ipv4_value_.imr_interface.s_addr =
       boost::asio::detail::socket_ops::host_to_network_long(
           network_interface.to_ulong());
-
-    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
-    ipv6_value_.ipv6mr_multiaddr = tmp_addr;
-    ipv6_value_.ipv6mr_interface = 0;
   }
 
   // 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.
   {
-    ipv4_value_.imr_multiaddr.s_addr =
-      boost::asio::detail::socket_ops::host_to_network_long(
-          boost::asio::ip::address_v4::any().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());
-
     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.elems, 16);
+    memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
     ipv6_value_.ipv6mr_interface = network_interface;
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/icmp.hpp b/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
index 14bb944..14c9df4 100644
--- a/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
@@ -46,12 +46,6 @@ public:
   /// The type of a ICMP endpoint.
   typedef basic_endpoint<icmp> endpoint;
 
-  /// (Deprecated: use resolver::query.) The type of a resolver query.
-  typedef basic_resolver_query<icmp> resolver_query;
-
-  /// (Deprecated: use resolver::iterator.) The type of a resolver iterator.
-  typedef basic_resolver_iterator<icmp> resolver_iterator;
-
   /// Construct to represent the IPv4 ICMP protocol.
   static icmp v4()
   {
@@ -102,9 +96,9 @@ public:
 
 private:
   // Construct with a specific family.
-  explicit icmp(int protocol, int family)
-    : protocol_(protocol),
-      family_(family)
+  explicit icmp(int protocol_id, int protocol_family)
+    : protocol_(protocol_id),
+      family_(protocol_family)
   {
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
index 11f06fc..4bf959c 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
@@ -57,6 +57,15 @@ address::address(const address& other)
 {
 }
 
+#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_;
@@ -65,6 +74,16 @@ address& address::operator=(const address& other)
   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;
@@ -159,6 +178,27 @@ address address::from_string(const std::string& str,
   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_)
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
index 8bdef19..3d24dd9 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
@@ -42,7 +42,7 @@ address_v4::address_v4(const address_v4::bytes_type& bytes)
 #endif // UCHAR_MAX > 0xFF
 
   using namespace std; // For memcpy.
-  memcpy(&addr_.s_addr, bytes.elems, 4);
+  memcpy(&addr_.s_addr, bytes.data(), 4);
 }
 
 address_v4::address_v4(unsigned long addr)
@@ -62,7 +62,11 @@ 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;
 }
 
@@ -119,24 +123,34 @@ address_v4 address_v4::from_string(
   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 IN_CLASSA(to_ulong());
+  return (to_ulong() & 0x80000000) == 0;
 }
 
 bool address_v4::is_class_b() const
 {
-  return IN_CLASSB(to_ulong());
+  return (to_ulong() & 0xC0000000) == 0x80000000;
 }
 
 bool address_v4::is_class_c() const
 {
-  return IN_CLASSC(to_ulong());
+  return (to_ulong() & 0xE0000000) == 0xC0000000;
 }
 
 bool address_v4::is_multicast() const
 {
-  return IN_MULTICAST(to_ulong());
+  return (to_ulong() & 0xF0000000) == 0xE0000000;
 }
 
 address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
index 5a3dddd..898f922 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
@@ -32,15 +32,14 @@ namespace asio {
 namespace ip {
 
 address_v6::address_v6()
-  : scope_id_(0)
+  : addr_(),
+    scope_id_(0)
 {
-  boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
-  addr_ = tmp_addr;
 }
 
 address_v6::address_v6(const address_v6::bytes_type& bytes,
-    unsigned long scope_id)
-  : scope_id_(scope_id)
+    unsigned long scope)
+  : scope_id_(scope)
 {
 #if UCHAR_MAX > 0xFF
   for (std::size_t i = 0; i < bytes.size(); ++i)
@@ -54,7 +53,7 @@ address_v6::address_v6(const address_v6::bytes_type& bytes,
 #endif // UCHAR_MAX > 0xFF
 
   using namespace std; // For memcpy.
-  memcpy(addr_.s6_addr, bytes.elems, 16);
+  memcpy(addr_.s6_addr, bytes.data(), 16);
 }
 
 address_v6::address_v6(const address_v6& other)
@@ -63,6 +62,14 @@ address_v6::address_v6(const address_v6& other)
 {
 }
 
+#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_;
@@ -70,11 +77,24 @@ address_v6& address_v6::operator=(const address_v6& other)
   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;
 }
 
@@ -141,7 +161,6 @@ address_v4 address_v6::to_v4() const
 
 bool address_v6::is_loopback() const
 {
-#if defined(__BORLANDC__)
   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)
@@ -150,15 +169,10 @@ bool address_v6::is_loopback() const
       && (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));
-#else
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_LOOPBACK(&addr_) != 0;
-#endif
 }
 
 bool address_v6::is_unspecified() const
 {
-#if defined(__BORLANDC__)
   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)
@@ -167,70 +181,70 @@ bool address_v6::is_unspecified() const
       && (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));
-#else
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_UNSPECIFIED(&addr_) != 0;
-#endif
 }
 
 bool address_v6::is_link_local() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_LINKLOCAL(&addr_) != 0;
+  return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0x80));
 }
 
 bool address_v6::is_site_local() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_SITELOCAL(&addr_) != 0;
+  return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0xc0));
 }
 
 bool address_v6::is_v4_mapped() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_V4MAPPED(&addr_) != 0;
+  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
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_V4COMPAT(&addr_) != 0;
+  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
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_MULTICAST(&addr_) != 0;
+  return (addr_.s6_addr[0] == 0xff);
 }
 
 bool address_v6::is_multicast_global() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_MC_GLOBAL(&addr_) != 0;
+  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x0e));
 }
 
 bool address_v6::is_multicast_link_local() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_MC_LINKLOCAL(&addr_) != 0;
+  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x02));
 }
 
 bool address_v6::is_multicast_node_local() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_MC_NODELOCAL(&addr_) != 0;
+  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x01));
 }
 
 bool address_v6::is_multicast_org_local() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_MC_ORGLOCAL(&addr_) != 0;
+  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x08));
 }
 
 bool address_v6::is_multicast_site_local() const
 {
-  using namespace boost::asio::detail;
-  return IN6_IS_ADDR_MC_SITELOCAL(&addr_) != 0;
+  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x05));
 }
 
 bool operator==(const address_v6& a1, const address_v6& a2)
@@ -256,8 +270,7 @@ bool operator<(const address_v6& a1, const address_v6& a2)
 address_v6 address_v6::loopback()
 {
   address_v6 tmp;
-  boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_LOOPBACK_INIT;
-  tmp.addr_ = tmp_addr;
+  tmp.addr_.s6_addr[15] = 1;
   return tmp;
 }
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp b/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
index db0554b..dff19ab 100644
--- a/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
@@ -77,12 +77,6 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new resolver implementation.
   void construct(implementation_type& impl)
   {
@@ -109,11 +103,12 @@ public:
   }
 
   /// Asynchronously resolve a query to a list of entries.
-  template <typename Handler>
+  template <typename ResolveHandler>
   void async_resolve(implementation_type& impl, const query_type& query,
-      Handler handler)
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    service_impl_.async_resolve(impl, query, handler);
+    service_impl_.async_resolve(impl, query,
+        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
   }
 
   /// Resolve an endpoint to a list of entries.
@@ -126,12 +121,25 @@ public:
   /// Asynchronously resolve an endpoint to a list of entries.
   template <typename ResolveHandler>
   void async_resolve(implementation_type& impl, const endpoint_type& endpoint,
-      ResolveHandler handler)
+      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    return service_impl_.async_resolve(impl, endpoint, 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_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/ip/tcp.hpp b/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
index 4163a8d..3d0524f 100644
--- a/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
@@ -49,12 +49,6 @@ public:
   /// The type of a TCP endpoint.
   typedef basic_endpoint<tcp> endpoint;
 
-  /// (Deprecated: use resolver::query.) The type of a resolver query.
-  typedef basic_resolver_query<tcp> resolver_query;
-
-  /// (Deprecated: use resolver::iterator.) The type of a resolver iterator.
-  typedef basic_resolver_iterator<tcp> resolver_iterator;
-
   /// Construct to represent the IPv4 TCP protocol.
   static tcp v4()
   {
@@ -146,8 +140,8 @@ public:
 
 private:
   // Construct with a specific family.
-  explicit tcp(int family)
-    : family_(family)
+  explicit tcp(int protocol_family)
+    : family_(protocol_family)
   {
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/udp.hpp b/3rdParty/Boost/src/boost/asio/ip/udp.hpp
index 40f5d3a..375a5fe 100644
--- a/3rdParty/Boost/src/boost/asio/ip/udp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/udp.hpp
@@ -46,12 +46,6 @@ public:
   /// The type of a UDP endpoint.
   typedef basic_endpoint<udp> endpoint;
 
-  /// (Deprecated: use resolver::query.) The type of a resolver query.
-  typedef basic_resolver_query<udp> resolver_query;
-
-  /// (Deprecated: use resolver::iterator.) The type of a resolver iterator.
-  typedef basic_resolver_iterator<udp> resolver_iterator;
-
   /// Construct to represent the IPv4 UDP protocol.
   static udp v4()
   {
@@ -102,8 +96,8 @@ public:
 
 private:
   // Construct with a specific family.
-  explicit udp(int family)
-    : family_(family)
+  explicit udp(int protocol_family)
+    : family_(protocol_family)
   {
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
index fcb53a0..7a5cc08 100644
--- a/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
@@ -66,14 +66,14 @@ public:
   }
 
   /// Construct an endpoint using the specified path name.
-  basic_endpoint(const char* path)
-    : impl_(path)
+  basic_endpoint(const char* path_name)
+    : impl_(path_name)
   {
   }
 
   /// Construct an endpoint using the specified path name.
-  basic_endpoint(const std::string& path)
-    : impl_(path)
+  basic_endpoint(const std::string& path_name)
+    : impl_(path_name)
   {
   }
 
@@ -83,6 +83,14 @@ public:
   {
   }
 
+#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)
   {
@@ -90,6 +98,15 @@ public:
     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
   {
@@ -115,9 +132,9 @@ public:
   }
 
   /// Set the underlying size of the endpoint in the native type.
-  void resize(std::size_t size)
+  void resize(std::size_t new_size)
   {
-    impl_.resize(size);
+    impl_.resize(new_size);
   }
 
   /// Get the capacity of the endpoint in the native type.
diff --git a/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp b/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
index 9ef6cd3..3cafae7 100644
--- a/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
@@ -52,7 +52,7 @@ inline void connect_pair(
 {
   boost::system::error_code ec;
   connect_pair(socket1, socket2, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "connect_pair");
 }
 
 template <typename Protocol, typename SocketService1, typename SocketService2>
diff --git a/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp b/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
index c527793..db0ccc3 100644
--- a/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
@@ -39,10 +39,10 @@ public:
   BOOST_ASIO_DECL endpoint();
 
   // Construct an endpoint using the specified path name.
-  BOOST_ASIO_DECL endpoint(const char* path);
+  BOOST_ASIO_DECL endpoint(const char* path_name);
 
   // Construct an endpoint using the specified path name.
-  BOOST_ASIO_DECL endpoint(const std::string& path);
+  BOOST_ASIO_DECL endpoint(const std::string& path_name);
 
   // Copy constructor.
   endpoint(const endpoint& other)
diff --git a/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp b/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
index a4c1e56..7a5dd62 100644
--- a/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
+++ b/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
@@ -38,31 +38,31 @@ endpoint::endpoint()
   init("", 0);
 }
 
-endpoint::endpoint(const char* path)
+endpoint::endpoint(const char* path_name)
 {
   using namespace std; // For strlen.
-  init(path, strlen(path));
+  init(path_name, strlen(path_name));
 }
 
-endpoint::endpoint(const std::string& path)
+endpoint::endpoint(const std::string& path_name)
 {
-  init(path.data(), path.length());
+  init(path_name.data(), path_name.length());
 }
 
-void endpoint::resize(std::size_t size)
+void endpoint::resize(std::size_t new_size)
 {
-  if (size > sizeof(boost::asio::detail::sockaddr_un_type))
+  if (new_size > sizeof(boost::asio::detail::sockaddr_un_type))
   {
     boost::system::error_code ec(boost::asio::error::invalid_argument);
     boost::asio::detail::throw_error(ec);
   }
-  else if (size == 0)
+  else if (new_size == 0)
   {
     path_length_ = 0;
   }
   else
   {
-    path_length_ = size
+    path_length_ = new_size
       - offsetof(boost::asio::detail::sockaddr_un_type, sun_path);
 
     // The path returned by the operating system may be NUL-terminated.
@@ -97,7 +97,7 @@ bool operator<(const endpoint& e1, const endpoint& e2)
   return e1.path() < e2.path();
 }
 
-void endpoint::init(const char* path, std::size_t path_length)
+void endpoint::init(const char* path_name, std::size_t path_length)
 {
   if (path_length > sizeof(data_.local.sun_path) - 1)
   {
@@ -109,7 +109,7 @@ void endpoint::init(const char* path, std::size_t path_length)
   using namespace std; // For memcpy.
   data_.local = boost::asio::detail::sockaddr_un_type();
   data_.local.sun_family = AF_UNIX;
-  memcpy(data_.local.sun_path, path, path_length);
+  memcpy(data_.local.sun_path, path_name, path_length);
   path_length_ = path_length;
 
   // NUL-terminate normal path names. Names that start with a NUL are in the
diff --git a/3rdParty/Boost/src/boost/asio/placeholders.hpp b/3rdParty/Boost/src/boost/asio/placeholders.hpp
index 19ddb66..6240e71 100644
--- a/3rdParty/Boost/src/boost/asio/placeholders.hpp
+++ b/3rdParty/Boost/src/boost/asio/placeholders.hpp
@@ -42,6 +42,11 @@ unspecified bytes_transferred;
 /// boost::asio::basic_resolver::async_resolve.
 unspecified iterator;
 
+/// An argument placeholder, for use with boost::bind(), that corresponds to
+/// the signal_number argument of a handler for asynchronous functions such as
+/// boost::asio::signal_set::async_wait.
+unspecified signal_number;
+
 #elif defined(__BORLANDC__) || defined(__GNUC__)
 
 inline boost::arg<1> error()
@@ -59,6 +64,11 @@ inline boost::arg<2> iterator()
   return boost::arg<2>();
 }
 
+inline boost::arg<2> signal_number()
+{
+  return boost::arg<2>();
+}
+
 #else
 
 namespace detail
@@ -82,6 +92,8 @@ static boost::arg<2>& bytes_transferred
   = boost::asio::placeholders::detail::placeholder<2>::get();
 static boost::arg<2>& iterator
   = boost::asio::placeholders::detail::placeholder<2>::get();
+static boost::arg<2>& signal_number
+  = boost::asio::placeholders::detail::placeholder<2>::get();
 
 #else
 
@@ -93,6 +105,8 @@ namespace
     = boost::asio::placeholders::detail::placeholder<2>::get();
   boost::arg<2>& iterator
     = boost::asio::placeholders::detail::placeholder<2>::get();
+  boost::arg<2>& signal_number
+    = boost::asio::placeholders::detail::placeholder<2>::get();
 } // namespace
 
 #endif
diff --git a/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp b/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
index cf953db..70f8fa4 100644
--- a/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
@@ -46,8 +46,12 @@ class basic_descriptor
     public descriptor_base
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// descriptor.
+  typedef typename DescriptorService::native_handle_type native_type;
+
   /// The native representation of a descriptor.
-  typedef typename DescriptorService::native_type native_type;
+  typedef typename DescriptorService::native_handle_type native_handle_type;
 
   /// A basic_descriptor is always the lowest layer.
   typedef basic_descriptor<DescriptorService> lowest_layer_type;
@@ -79,14 +83,50 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_descriptor(boost::asio::io_service& io_service,
-      const native_type& native_descriptor)
+      const native_handle_type& native_descriptor)
     : basic_io_object<DescriptorService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, native_descriptor, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        native_descriptor, ec);
+    boost::asio::detail::throw_error(ec, "assign");
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_descriptor from another.
+  /**
+   * This constructor moves a descriptor from one object to another.
+   *
+   * @param other The other basic_descriptor object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_descriptor(io_service&) constructor.
+   */
+  basic_descriptor(basic_descriptor&& other)
+    : basic_io_object<DescriptorService>(
+        BOOST_ASIO_MOVE_CAST(basic_descriptor)(other))
+  {
+  }
+
+  /// Move-assign a basic_descriptor from another.
+  /**
+   * This assignment operator moves a descriptor from one object to another.
+   *
+   * @param other The other basic_descriptor object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_descriptor(io_service&) constructor.
+   */
+  basic_descriptor& operator=(basic_descriptor&& other)
+  {
+    basic_io_object<DescriptorService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_descriptor)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Get a reference to the lowest layer.
   /**
    * This function returns a reference to the lowest layer in a stack of
@@ -123,11 +163,12 @@ public:
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const native_type& native_descriptor)
+  void assign(const native_handle_type& native_descriptor)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, native_descriptor, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(),
+        native_descriptor, ec);
+    boost::asio::detail::throw_error(ec, "assign");
   }
 
   /// Assign an existing native descriptor to the descriptor.
@@ -138,16 +179,17 @@ public:
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  boost::system::error_code assign(const native_type& native_descriptor,
+  boost::system::error_code assign(const native_handle_type& native_descriptor,
       boost::system::error_code& ec)
   {
-    return this->service.assign(this->implementation, native_descriptor, ec);
+    return this->get_service().assign(
+        this->get_implementation(), native_descriptor, ec);
   }
 
   /// Determine whether the descriptor is open.
   bool is_open() const
   {
-    return this->service.is_open(this->implementation);
+    return this->get_service().is_open(this->implementation);
   }
 
   /// Close the descriptor.
@@ -156,13 +198,14 @@ public:
    * write operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
-   * @throws boost::system::system_error Thrown on failure.
+   * @throws boost::system::system_error Thrown on failure. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
    */
   void close()
   {
     boost::system::error_code ec;
-    this->service.close(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().close(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
   }
 
   /// Close the descriptor.
@@ -171,14 +214,16 @@ public:
    * write operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
-   * @param ec Set to indicate what error occurred, if any.
+   * @param ec Set to indicate what error occurred, if any. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->service.close(this->implementation, ec);
+    return this->get_service().close(this->get_implementation(), ec);
   }
 
-  /// Get the native descriptor representation.
+  /// (Deprecated: Use native_handle().) Get the native descriptor
+  /// representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * descriptor. This is intended to allow access to native descriptor
@@ -186,7 +231,33 @@ public:
    */
   native_type native()
   {
-    return this->service.native(this->implementation);
+    return this->get_service().native_handle(this->implementation);
+  }
+
+  /// Get the native descriptor representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * descriptor. This is intended to allow access to native descriptor
+   * functionality that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return this->get_service().native_handle(this->implementation);
+  }
+
+  /// Release ownership of the native descriptor implementation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * descriptor. After calling this function, @c is_open() returns false. The
+   * caller is responsible for closing the descriptor.
+   *
+   * All outstanding asynchronous read or write operations will finish
+   * immediately, and the handlers for cancelled operations will be passed the
+   * boost::asio::error::operation_aborted error.
+   */
+  native_handle_type release()
+  {
+    return this->get_service().release(this->implementation);
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
@@ -200,8 +271,8 @@ public:
   void cancel()
   {
     boost::system::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
@@ -214,7 +285,7 @@ public:
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    return this->get_service().cancel(this->get_implementation(), ec);
   }
 
   /// Perform an IO control command on the descriptor.
@@ -243,8 +314,8 @@ public:
   void io_control(IoControlCommand& command)
   {
     boost::system::error_code ec;
-    this->service.io_control(this->implementation, command, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    boost::asio::detail::throw_error(ec, "io_control");
   }
 
   /// Perform an IO control command on the descriptor.
@@ -278,7 +349,128 @@ public:
   boost::system::error_code io_control(IoControlCommand& command,
       boost::system::error_code& ec)
   {
-    return this->service.io_control(this->implementation, command, ec);
+    return this->get_service().io_control(
+        this->get_implementation(), command, ec);
+  }
+
+  /// Gets the non-blocking mode of the descriptor.
+  /**
+   * @returns @c true if the descriptor's synchronous operations will fail with
+   * boost::asio::error::would_block if they are unable to perform the requested
+   * operation immediately. If @c false, synchronous operations will block
+   * until complete.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  bool non_blocking() const
+  {
+    return this->get_service().non_blocking(this->implementation);
+  }
+
+  /// Sets the non-blocking mode of the descriptor.
+  /**
+   * @param mode If @c true, the descriptor's synchronous operations will fail
+   * with boost::asio::error::would_block if they are unable to perform the
+   * requested operation immediately. If @c false, synchronous operations will
+   * block until complete.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  void non_blocking(bool mode)
+  {
+    boost::system::error_code ec;
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    boost::asio::detail::throw_error(ec, "non_blocking");
+  }
+
+  /// Sets the non-blocking mode of the descriptor.
+  /**
+   * @param mode If @c true, the descriptor's synchronous operations will fail
+   * with boost::asio::error::would_block if they are unable to perform the
+   * requested operation immediately. If @c false, synchronous operations will
+   * block until complete.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note The non-blocking mode has no effect on the behaviour of asynchronous
+   * operations. Asynchronous operations will never fail with the error
+   * boost::asio::error::would_block.
+   */
+  boost::system::error_code non_blocking(
+      bool mode, boost::system::error_code& ec)
+  {
+    return this->get_service().non_blocking(
+        this->get_implementation(), mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native descriptor implementation.
+  /**
+   * This function is used to retrieve the non-blocking mode of the underlying
+   * native descriptor. This mode has no effect on the behaviour of the
+   * descriptor object's synchronous operations.
+   *
+   * @returns @c true if the underlying descriptor is in non-blocking mode and
+   * direct system calls may fail with boost::asio::error::would_block (or the
+   * equivalent system error).
+   *
+   * @note The current non-blocking mode is cached by the descriptor object.
+   * Consequently, the return value may be incorrect if the non-blocking mode
+   * was set directly on the native descriptor.
+   */
+  bool native_non_blocking() const
+  {
+    return this->get_service().native_non_blocking(this->implementation);
+  }
+
+  /// Sets the non-blocking mode of the native descriptor implementation.
+  /**
+   * This function is used to modify the non-blocking mode of the underlying
+   * native descriptor. It has no effect on the behaviour of the descriptor
+   * object's synchronous operations.
+   *
+   * @param mode If @c true, the underlying descriptor is put into non-blocking
+   * mode and direct system calls may fail with boost::asio::error::would_block
+   * (or the equivalent system error).
+   *
+   * @throws boost::system::system_error Thrown on failure. If the @c mode is
+   * @c false, but the current value of @c non_blocking() is @c true, this
+   * function fails with boost::asio::error::invalid_argument, as the
+   * combination does not make sense.
+   */
+  void native_non_blocking(bool mode)
+  {
+    boost::system::error_code ec;
+    this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
+    boost::asio::detail::throw_error(ec, "native_non_blocking");
+  }
+
+  /// Sets the non-blocking mode of the native descriptor implementation.
+  /**
+   * This function is used to modify the non-blocking mode of the underlying
+   * native descriptor. It has no effect on the behaviour of the descriptor
+   * object's synchronous operations.
+   *
+   * @param mode If @c true, the underlying descriptor is put into non-blocking
+   * mode and direct system calls may fail with boost::asio::error::would_block
+   * (or the equivalent system error).
+   *
+   * @param ec Set to indicate what error occurred, if any. If the @c mode is
+   * @c false, but the current value of @c non_blocking() is @c true, this
+   * function fails with boost::asio::error::invalid_argument, as the
+   * combination does not make sense.
+   */
+  boost::system::error_code native_non_blocking(
+      bool mode, boost::system::error_code& ec)
+  {
+    return this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
   }
 
 protected:
diff --git a/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp b/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
index ee08567..61152c1 100644
--- a/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
@@ -21,6 +21,7 @@
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/posix/basic_descriptor.hpp>
@@ -49,8 +50,13 @@ class basic_stream_descriptor
   : public basic_descriptor<StreamDescriptorService>
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// descriptor.
+  typedef typename StreamDescriptorService::native_handle_type native_type;
+
   /// The native representation of a descriptor.
-  typedef typename StreamDescriptorService::native_type native_type;
+  typedef typename StreamDescriptorService::native_handle_type
+    native_handle_type;
 
   /// Construct a basic_stream_descriptor without opening it.
   /**
@@ -81,11 +87,47 @@ public:
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_descriptor(boost::asio::io_service& io_service,
-      const native_type& native_descriptor)
+      const native_handle_type& native_descriptor)
     : basic_descriptor<StreamDescriptorService>(io_service, native_descriptor)
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_stream_descriptor from another.
+  /**
+   * This constructor moves a stream descriptor from one object to another.
+   *
+   * @param other The other basic_stream_descriptor object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_descriptor(io_service&) constructor.
+   */
+  basic_stream_descriptor(basic_stream_descriptor&& other)
+    : basic_descriptor<StreamDescriptorService>(
+        BOOST_ASIO_MOVE_CAST(basic_stream_descriptor)(other))
+  {
+  }
+
+  /// Move-assign a basic_stream_descriptor from another.
+  /**
+   * This assignment operator moves a stream descriptor from one object to
+   * another.
+   *
+   * @param other The other basic_stream_descriptor object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_descriptor(io_service&) constructor.
+   */
+  basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
+  {
+    basic_descriptor<StreamDescriptorService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_stream_descriptor)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Write some data to the descriptor.
   /**
    * This function is used to write data to the stream descriptor. The function
@@ -117,8 +159,9 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.write_some(this->implementation, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
     return s;
   }
 
@@ -142,7 +185,8 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.write_some(this->implementation, buffers, ec);
+    return this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
   }
 
   /// Start an asynchronous write.
@@ -182,9 +226,14 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_write_some(this->implementation, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_write_some(this->get_implementation(),
+        buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the descriptor.
@@ -219,8 +268,9 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.read_some(this->implementation, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
     return s;
   }
 
@@ -245,7 +295,8 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.read_some(this->implementation, buffers, ec);
+    return this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
   }
 
   /// Start an asynchronous read.
@@ -286,9 +337,14 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_read_some(this->implementation, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_read_some(this->get_implementation(),
+        buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp b/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
index 2e5cb47..ccb3d38 100644
--- a/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
@@ -35,7 +35,8 @@ namespace posix {
 class descriptor_base
 {
 public:
-  /// IO control command to set the blocking mode of the descriptor.
+  /// (Deprecated: Use non_blocking().) IO control command to set the blocking
+  /// mode of the descriptor.
   /**
    * Implements the FIONBIO IO control command.
    *
diff --git a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
index c582b8e..7b74944 100644
--- a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
@@ -57,11 +57,18 @@ public:
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native descriptor type.
+  /// (Deprecated: Use native_handle_type.) The native descriptor type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_type native_type;
+  typedef service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native descriptor type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new stream descriptor service for the specified io_service.
@@ -71,18 +78,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined descriptorr objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new stream descriptor implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new stream descriptor implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another stream descriptor implementation.
+  void move_assign(implementation_type& impl,
+      stream_descriptor_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a stream descriptor implementation.
   void destroy(implementation_type& impl)
   {
@@ -91,7 +109,8 @@ public:
 
   /// Assign an existing native descriptor to a stream descriptor.
   boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_descriptor, boost::system::error_code& ec)
+      const native_handle_type& native_descriptor,
+      boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, native_descriptor, ec);
   }
@@ -109,10 +128,23 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native descriptor implementation.
+  /// (Deprecated: Use native_handle().) Get the native descriptor
+  /// implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native descriptor implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Release ownership of the native descriptor implementation.
+  native_handle_type release(implementation_type& impl)
+  {
+    return service_impl_.release(impl);
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
@@ -130,6 +162,32 @@ public:
     return service_impl_.io_control(impl, command, ec);
   }
 
+  /// Gets the non-blocking mode of the descriptor.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the descriptor.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.non_blocking(impl, mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native descriptor implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.native_non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the native descriptor implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.native_non_blocking(impl, mode, ec);
+  }
+
   /// Write the given data to the stream.
   template <typename ConstBufferSequence>
   std::size_t write_some(implementation_type& impl,
@@ -141,9 +199,11 @@ public:
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, WriteHandler descriptorr)
+      const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some(impl, buffers, descriptorr);
+    service_impl_.async_write_some(impl, buffers,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the stream.
@@ -157,12 +217,20 @@ public:
   /// Start an asynchronous read.
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, ReadHandler descriptorr)
+      const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some(impl, buffers, descriptorr);
+    service_impl_.async_read_some(impl, buffers,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp b/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
index 783c4c2..ec2e842 100644
--- a/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
@@ -68,11 +68,18 @@ public:
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native socket type.
+  /// (Deprecated: Use native_handle_type.) The native socket type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_type native_type;
+  typedef typename service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native socket type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new raw socket service for the specified io_service.
@@ -83,18 +90,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new raw socket implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new raw socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another raw socket implementation.
+  void move_assign(implementation_type& impl,
+      raw_socket_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a raw socket implementation.
   void destroy(implementation_type& impl)
   {
@@ -114,7 +132,7 @@ public:
 
   /// Assign an existing native socket to a raw socket.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_type& native_socket,
+      const protocol_type& protocol, const native_handle_type& native_socket,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_socket, ec);
@@ -133,10 +151,16 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native socket implementation.
+  /// (Deprecated: Use native_handle().) Get the native socket implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native socket implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
@@ -177,9 +201,11 @@ public:
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, ConnectHandler handler)
+      const endpoint_type& peer_endpoint,
+      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint, handler);
+    service_impl_.async_connect(impl, peer_endpoint,
+        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
   }
 
   /// Set a socket option.
@@ -206,6 +232,32 @@ public:
     return service_impl_.io_control(impl, command, ec);
   }
 
+  /// Gets the non-blocking mode of the socket.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.non_blocking(impl, mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.native_non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.native_non_blocking(impl, mode, ec);
+  }
+
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
@@ -239,9 +291,11 @@ public:
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send(implementation_type& impl, const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send(impl, buffers, flags, handler);
+    service_impl_.async_send(impl, buffers, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Send raw data to the specified endpoint.
@@ -257,9 +311,11 @@ public:
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send_to(implementation_type& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send_to(impl, buffers, destination, flags, handler);
+    service_impl_.async_send_to(impl, buffers, destination, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data from the peer.
@@ -275,9 +331,11 @@ public:
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive(impl, buffers, flags, handler);
+    service_impl_.async_receive(impl, buffers, flags,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Receive raw data with the endpoint of the sender.
@@ -294,13 +352,20 @@ public:
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
     service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
-        handler);
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/read.hpp b/3rdParty/Boost/src/boost/asio/read.hpp
index fd13e75..88d2dc2 100644
--- a/3rdParty/Boost/src/boost/asio/read.hpp
+++ b/3rdParty/Boost/src/boost/asio/read.hpp
@@ -80,6 +80,46 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
  *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param buffers One or more buffers into which the data will be read. The sum
+ * of the buffer sizes indicates the maximum number of bytes to read from the
+ * stream.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @par Example
+ * To read into a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::read(s, boost::asio::buffer(data, size), ec); @endcode
+ * See the @ref buffer documentation for information on reading into multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read(
+ *     s, buffers,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncReadStream, typename MutableBufferSequence>
+std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
+    boost::system::error_code& ec);
+
+/// Attempt to read a certain amount of data from a stream before returning.
+/**
+ * This function is used to read a certain number of bytes of data from a
+ * stream. The call will block until one of the following conditions is true:
+ *
+ * @li The supplied buffers are full. That is, the bytes transferred is equal to
+ * the sum of the buffer sizes.
+ *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
@@ -201,6 +241,34 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
  * This function is used to read a certain number of bytes of data from a
  * stream. The call will block until one of the following conditions is true:
  *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b The basic_streambuf object into which the data will be read.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read(
+ *     s, b,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncReadStream, typename Allocator>
+std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec);
+
+/// Attempt to read a certain amount of data from a stream before returning.
+/**
+ * This function is used to read a certain number of bytes of data from a
+ * stream. The call will block until one of the following conditions is true:
+ *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
@@ -347,7 +415,7 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename ReadHandler>
 void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    ReadHandler handler);
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
@@ -415,7 +483,8 @@ void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, ReadHandler handler);
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 #if !defined(BOOST_NO_IOSTREAM)
 
@@ -467,7 +536,7 @@ void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  */
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 void async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    ReadHandler handler);
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
@@ -526,7 +595,8 @@ void async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
 template <typename AsyncReadStream, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
 void async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, ReadHandler handler);
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
diff --git a/3rdParty/Boost/src/boost/asio/read_at.hpp b/3rdParty/Boost/src/boost/asio/read_at.hpp
index 1feba6c..78745f3 100644
--- a/3rdParty/Boost/src/boost/asio/read_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/read_at.hpp
@@ -88,6 +88,52 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
  *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the device's
+ * read_some_at function.
+ *
+ * @param d The device from which the data is to be read. The type must support
+ * the SyncRandomAccessReadDevice concept.
+ *
+ * @param offset The offset at which the data will be read.
+ *
+ * @param buffers One or more buffers into which the data will be read. The sum
+ * of the buffer sizes indicates the maximum number of bytes to read from the
+ * device.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @par Example
+ * To read into a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::read_at(d, 42,
+ *     boost::asio::buffer(data, size), ec); @endcode
+ * See the @ref buffer documentation for information on reading into multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read_at(
+ *     d, 42, buffers,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
+std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    boost::system::error_code& ec);
+
+/// Attempt to read a certain amount of data at the specified offset before
+/// returning.
+/**
+ * This function is used to read a certain number of bytes of data from a
+ * random access device at the specified offset. The call will block until one
+ * of the following conditions is true:
+ *
+ * @li The supplied buffers are full. That is, the bytes transferred is equal to
+ * the sum of the buffer sizes.
+ *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the device's
@@ -224,6 +270,39 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * random access device at the specified offset. The call will block until one
  * of the following conditions is true:
  *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the device's
+ * read_some_at function.
+ *
+ * @param d The device from which the data is to be read. The type must support
+ * the SyncRandomAccessReadDevice concept.
+ *
+ * @param offset The offset at which the data will be read.
+ *
+ * @param b The basic_streambuf object into which the data will be read.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read_at(
+ *     d, 42, b,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncRandomAccessReadDevice, typename Allocator>
+std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec);
+
+/// Attempt to read a certain amount of data at the specified offset before
+/// returning.
+/**
+ * This function is used to read a certain number of bytes of data from a
+ * random access device at the specified offset. The call will block until one
+ * of the following conditions is true:
+ *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the device's
@@ -377,7 +456,8 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename ReadHandler>
 void async_read_at(AsyncRandomAccessReadDevice& d, boost::uint64_t offset,
-    const MutableBufferSequence& buffers, ReadHandler handler);
+    const MutableBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read a certain amount of data at the
 /// specified offset.
@@ -448,7 +528,8 @@ template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, ReadHandler handler);
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 #if !defined(BOOST_NO_IOSTREAM)
 
@@ -500,7 +581,7 @@ void async_read_at(AsyncRandomAccessReadDevice& d,
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename ReadHandler>
 void async_read_at(AsyncRandomAccessReadDevice& d, boost::uint64_t offset,
-    basic_streambuf<Allocator>& b, ReadHandler handler);
+    basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read a certain amount of data at the
 /// specified offset.
@@ -559,7 +640,8 @@ template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
 void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, ReadHandler handler);
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
diff --git a/3rdParty/Boost/src/boost/asio/read_until.hpp b/3rdParty/Boost/src/boost/asio/read_until.hpp
index 546537b..e331015 100644
--- a/3rdParty/Boost/src/boost/asio/read_until.hpp
+++ b/3rdParty/Boost/src/boost/asio/read_until.hpp
@@ -36,30 +36,16 @@ namespace asio {
 
 namespace detail
 {
-#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
+  char (&has_result_type_helper(...))[2];
+
   template <typename T>
-  struct has_result_type
-  {
-    template <typename U> struct inner
-    {
-        struct big { char a[100]; };
-        static big helper(U, ...);
-        static char helper(U, typename U::result_type* = 0);
-    };
-    static const T& ref();
-    enum { value = (sizeof((inner<const T&>::helper)((ref)())) == 1) };
-  };
-#else // BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
+  char has_result_type_helper(T*, typename T::result_type* = 0);
+
   template <typename T>
   struct has_result_type
   {
-    struct big { char a[100]; };
-    template <typename U> static big helper(U, ...);
-    template <typename U> static char helper(U, typename U::result_type* = 0);
-    static const T& ref();
-    enum { value = (sizeof((helper)((ref)())) == 1) };
+    enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
   };
-#endif // BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
 } // namespace detail
 
 /// Type trait used to determine whether a type can be used as a match condition
@@ -604,7 +590,7 @@ std::size_t read_until(SyncReadStream& s,
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    char delim, ReadHandler handler);
+    char delim, BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read data into a streambuf until it
 /// contains a specified delimiter.
@@ -687,7 +673,7 @@ void async_read_until(AsyncReadStream& s,
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
-    ReadHandler handler);
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read data into a streambuf until some
 /// part of its data matches a regular expression.
@@ -774,7 +760,7 @@ void async_read_until(AsyncReadStream& s,
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    ReadHandler handler);
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read data into a streambuf until a
 /// function object indicates a match.
@@ -903,7 +889,7 @@ template <typename AsyncReadStream, typename Allocator,
     typename MatchCondition, typename ReadHandler>
 void async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, ReadHandler handler,
+    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
     typename boost::enable_if<is_match_condition<MatchCondition> >::type* = 0);
 
 /*@}*/
diff --git a/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp b/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp
new file mode 100644
index 0000000..db77a68
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp
@@ -0,0 +1,341 @@
+//
+// seq_packet_socket_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_SEQ_PACKET_SOCKET_SERVICE_HPP
+#define BOOST_ASIO_SEQ_PACKET_SOCKET_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 <cstddef>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_socket_service.hpp>
+#else
+# include <boost/asio/detail/reactive_socket_service.hpp>
+#endif
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a sequenced packet socket.
+template <typename Protocol>
+class seq_packet_socket_service
+#if defined(GENERATING_DOCUMENTATION)
+  : public boost::asio::io_service::service
+#else
+  : public boost::asio::detail::service_base<
+      seq_packet_socket_service<Protocol> >
+#endif
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// The unique service identifier.
+  static boost::asio::io_service::id id;
+#endif
+
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+private:
+  // The type of the platform-specific implementation.
+#if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
+#else
+  typedef detail::reactive_socket_service<Protocol> service_impl_type;
+#endif
+
+public:
+  /// The type of a sequenced packet socket implementation.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef typename service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// (Deprecated: Use native_handle_type.) The native socket type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_type;
+#else
+  typedef typename service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native socket type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename service_impl_type::native_handle_type native_handle_type;
+#endif
+
+  /// Construct a new sequenced packet socket service for the specified
+  /// io_service.
+  explicit seq_packet_socket_service(boost::asio::io_service& io_service)
+    : boost::asio::detail::service_base<
+        seq_packet_socket_service<Protocol> >(io_service),
+      service_impl_(io_service)
+  {
+  }
+
+  /// Construct a new sequenced packet socket implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new sequenced packet socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another sequenced packet socket implementation.
+  void move_assign(implementation_type& impl,
+      seq_packet_socket_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroy a sequenced packet socket implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Open a sequenced packet socket.
+  boost::system::error_code open(implementation_type& impl,
+      const protocol_type& protocol, boost::system::error_code& ec)
+  {
+    if (protocol.type() == SOCK_SEQPACKET)
+      service_impl_.open(impl, protocol, ec);
+    else
+      ec = boost::asio::error::invalid_argument;
+    return ec;
+  }
+
+  /// Assign an existing native socket to a sequenced packet socket.
+  boost::system::error_code assign(implementation_type& impl,
+      const protocol_type& protocol, const native_handle_type& native_socket,
+      boost::system::error_code& ec)
+  {
+    return service_impl_.assign(impl, protocol, native_socket, ec);
+  }
+
+  /// Determine whether the socket is open.
+  bool is_open(const implementation_type& impl) const
+  {
+    return service_impl_.is_open(impl);
+  }
+
+  /// Close a sequenced packet socket implementation.
+  boost::system::error_code close(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return service_impl_.close(impl, ec);
+  }
+
+  /// (Deprecated: Use native_handle().) Get the native socket implementation.
+  native_type native(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native socket implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Cancel all asynchronous operations associated with the socket.
+  boost::system::error_code cancel(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return service_impl_.cancel(impl, ec);
+  }
+
+  /// Determine whether the socket is at the out-of-band data mark.
+  bool at_mark(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    return service_impl_.at_mark(impl, ec);
+  }
+
+  /// Determine the number of bytes available for reading.
+  std::size_t available(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    return service_impl_.available(impl, ec);
+  }
+
+  /// Bind the sequenced packet socket to the specified local endpoint.
+  boost::system::error_code bind(implementation_type& impl,
+      const endpoint_type& endpoint, boost::system::error_code& ec)
+  {
+    return service_impl_.bind(impl, endpoint, ec);
+  }
+
+  /// Connect the sequenced packet socket to the specified endpoint.
+  boost::system::error_code connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, boost::system::error_code& ec)
+  {
+    return service_impl_.connect(impl, peer_endpoint, ec);
+  }
+
+  /// Start an asynchronous connect.
+  template <typename ConnectHandler>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint,
+      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
+  {
+    service_impl_.async_connect(impl, peer_endpoint,
+        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+  }
+
+  /// Set a socket option.
+  template <typename SettableSocketOption>
+  boost::system::error_code set_option(implementation_type& impl,
+      const SettableSocketOption& option, boost::system::error_code& ec)
+  {
+    return service_impl_.set_option(impl, option, ec);
+  }
+
+  /// Get a socket option.
+  template <typename GettableSocketOption>
+  boost::system::error_code get_option(const implementation_type& impl,
+      GettableSocketOption& option, boost::system::error_code& ec) const
+  {
+    return service_impl_.get_option(impl, option, ec);
+  }
+
+  /// Perform an IO control command on the socket.
+  template <typename IoControlCommand>
+  boost::system::error_code io_control(implementation_type& impl,
+      IoControlCommand& command, boost::system::error_code& ec)
+  {
+    return service_impl_.io_control(impl, command, ec);
+  }
+
+  /// Gets the non-blocking mode of the socket.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.non_blocking(impl, mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.native_non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.native_non_blocking(impl, mode, ec);
+  }
+
+  /// Get the local endpoint.
+  endpoint_type local_endpoint(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    return service_impl_.local_endpoint(impl, ec);
+  }
+
+  /// Get the remote endpoint.
+  endpoint_type remote_endpoint(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    return service_impl_.remote_endpoint(impl, ec);
+  }
+
+  /// Disable sends or receives on the socket.
+  boost::system::error_code shutdown(implementation_type& impl,
+      socket_base::shutdown_type what, boost::system::error_code& ec)
+  {
+    return service_impl_.shutdown(impl, what, ec);
+  }
+
+  /// Send the given data to the peer.
+  template <typename ConstBufferSequence>
+  std::size_t send(implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      socket_base::message_flags flags, boost::system::error_code& ec)
+  {
+    return service_impl_.send(impl, buffers, flags, ec);
+  }
+
+  /// Start an asynchronous send.
+  template <typename ConstBufferSequence, typename WriteHandler>
+  void async_send(implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+  {
+    service_impl_.async_send(impl, buffers, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+  }
+
+  /// Receive some data from the peer.
+  template <typename MutableBufferSequence>
+  std::size_t receive(implementation_type& impl,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    return service_impl_.receive_with_flags(impl,
+        buffers, in_flags, out_flags, ec);
+  }
+
+  /// Start an asynchronous receive.
+  template <typename MutableBufferSequence, typename ReadHandler>
+  void async_receive(implementation_type& impl,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  {
+    service_impl_.async_receive_with_flags(impl, buffers, in_flags,
+        out_flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+  }
+
+private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
+  // The platform-specific implementation.
+  service_impl_type service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SEQ_PACKET_SOCKET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
index 1a8a11b..0b6e794 100644
--- a/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
@@ -63,11 +63,18 @@ public:
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native handle type.
+  /// (Deprecated: Use native_handle_type.) The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_type native_type;
+  typedef service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native handle type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new serial port service for the specified io_service.
@@ -77,18 +84,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new serial port implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new serial port implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another serial port implementation.
+  void move_assign(implementation_type& impl,
+      serial_port_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a serial port implementation.
   void destroy(implementation_type& impl)
   {
@@ -104,9 +122,9 @@ public:
 
   /// Assign an existing native handle to a serial port.
   boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_handle, boost::system::error_code& ec)
+      const native_handle_type& handle, boost::system::error_code& ec)
   {
-    return service_impl_.assign(impl, native_handle, ec);
+    return service_impl_.assign(impl, handle, ec);
   }
 
   /// Determine whether the handle is open.
@@ -122,10 +140,16 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native handle implementation.
+  /// (Deprecated: Use native_handle().) Get the native handle implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native handle implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
@@ -169,9 +193,11 @@ public:
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, WriteHandler handler)
+      const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some(impl, buffers, handler);
+    service_impl_.async_write_some(impl, buffers,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the stream.
@@ -185,12 +211,20 @@ public:
   /// Start an asynchronous read.
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, ReadHandler handler)
+      const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some(impl, buffers, handler);
+    service_impl_.async_read_some(impl, buffers,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/signal_set.hpp b/3rdParty/Boost/src/boost/asio/signal_set.hpp
new file mode 100644
index 0000000..62b3dd1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/signal_set.hpp
@@ -0,0 +1,30 @@
+//
+// signal_set.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_SIGNAL_SET_HPP
+#define BOOST_ASIO_SIGNAL_SET_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_signal_set.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of a signal set.
+typedef basic_signal_set<> signal_set;
+
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_SIGNAL_SET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/signal_set_service.hpp b/3rdParty/Boost/src/boost/asio/signal_set_service.hpp
new file mode 100644
index 0000000..b372eb3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/signal_set_service.hpp
@@ -0,0 +1,128 @@
+//
+// signal_set_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_SIGNAL_SET_SERVICE_HPP
+#define BOOST_ASIO_SIGNAL_SET_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/asio/detail/signal_set_service.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a signal set.
+class signal_set_service
+#if defined(GENERATING_DOCUMENTATION)
+  : public boost::asio::io_service::service
+#else
+  : public boost::asio::detail::service_base<signal_set_service>
+#endif
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// The unique service identifier.
+  static boost::asio::io_service::id id;
+#endif
+
+public:
+  /// The type of a signal set implementation.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef detail::signal_set_service::implementation_type implementation_type;
+#endif
+
+  /// Construct a new signal set service for the specified io_service.
+  explicit signal_set_service(boost::asio::io_service& io_service)
+    : boost::asio::detail::service_base<signal_set_service>(io_service),
+      service_impl_(io_service)
+  {
+  }
+
+  /// Construct a new signal set implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a signal set implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Add a signal to a signal_set.
+  boost::system::error_code add(implementation_type& impl,
+      int signal_number, boost::system::error_code& ec)
+  {
+    return service_impl_.add(impl, signal_number, ec);
+  }
+
+  /// Remove a signal to a signal_set.
+  boost::system::error_code remove(implementation_type& impl,
+      int signal_number, boost::system::error_code& ec)
+  {
+    return service_impl_.remove(impl, signal_number, ec);
+  }
+
+  /// Remove all signals from a signal_set.
+  boost::system::error_code clear(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return service_impl_.clear(impl, ec);
+  }
+
+  /// Cancel all operations associated with the signal set.
+  boost::system::error_code cancel(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return service_impl_.cancel(impl, ec);
+  }
+
+  // Start an asynchronous operation to wait for a signal to be delivered.
+  template <typename SignalHandler>
+  void async_wait(implementation_type& impl,
+      BOOST_ASIO_MOVE_ARG(SignalHandler) handler)
+  {
+    service_impl_.async_wait(impl,
+        BOOST_ASIO_MOVE_CAST(SignalHandler)(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.
+  detail::signal_set_service service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SIGNAL_SET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp b/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
index f287c65..073b299 100644
--- a/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
@@ -68,11 +68,18 @@ public:
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native acceptor type.
+  /// (Deprecated: Use native_handle_type.) The native acceptor type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_type native_type;
+  typedef typename service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native acceptor type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new socket acceptor service for the specified io_service.
@@ -83,18 +90,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new socket acceptor implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new socket acceptor implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another socket acceptor implementation.
+  void move_assign(implementation_type& impl,
+      socket_acceptor_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a socket acceptor implementation.
   void destroy(implementation_type& impl)
   {
@@ -110,7 +128,7 @@ public:
 
   /// Assign an existing native acceptor to a socket acceptor.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_type& native_acceptor,
+      const protocol_type& protocol, const native_handle_type& native_acceptor,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_acceptor, ec);
@@ -151,10 +169,16 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native acceptor implementation.
+  /// (Deprecated: Use native_handle().) Get the native acceptor implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native acceptor implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
   }
 
   /// Set a socket option.
@@ -181,6 +205,32 @@ public:
     return service_impl_.io_control(impl, command, ec);
   }
 
+  /// Gets the non-blocking mode of the acceptor.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the acceptor.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.non_blocking(impl, mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native acceptor implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.native_non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the native acceptor implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.native_non_blocking(impl, mode, ec);
+  }
+
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
@@ -201,12 +251,20 @@ public:
   template <typename SocketService, typename AcceptHandler>
   void async_accept(implementation_type& impl,
       basic_socket<protocol_type, SocketService>& peer,
-      endpoint_type* peer_endpoint, AcceptHandler handler)
+      endpoint_type* peer_endpoint,
+      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
   {
-    service_impl_.async_accept(impl, peer, peer_endpoint, handler);
+    service_impl_.async_accept(impl, peer, peer_endpoint,
+        BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/socket_base.hpp b/3rdParty/Boost/src/boost/asio/socket_base.hpp
index f5bac91..30eba2a 100644
--- a/3rdParty/Boost/src/boost/asio/socket_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/socket_base.hpp
@@ -63,6 +63,9 @@ public:
 
   /// 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
   BOOST_STATIC_CONSTANT(int,
       message_peek = boost::asio::detail::message_peek);
@@ -70,6 +73,8 @@ public:
       message_out_of_band = boost::asio::detail::message_out_of_band);
   BOOST_STATIC_CONSTANT(int,
       message_do_not_route = boost::asio::detail::message_do_not_route);
+  BOOST_STATIC_CONSTANT(int,
+      message_end_of_record = boost::asio::detail::message_end_of_record);
 #endif
 
   /// Socket option to permit sending of broadcast messages.
@@ -442,7 +447,8 @@ public:
     enable_connection_aborted;
 #endif
 
-  /// IO control command to set the blocking mode of the socket.
+  /// (Deprecated: Use non_blocking().) IO control command to
+  /// set the blocking mode of the socket.
   /**
    * Implements the FIONBIO IO control command.
    *
diff --git a/3rdParty/Boost/src/boost/asio/strand.hpp b/3rdParty/Boost/src/boost/asio/strand.hpp
index 2928167..e8339fd 100644
--- a/3rdParty/Boost/src/boost/asio/strand.hpp
+++ b/3rdParty/Boost/src/boost/asio/strand.hpp
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/strand_service.hpp>
 #include <boost/asio/detail/wrapped_handler.hpp>
 #include <boost/asio/io_service.hpp>
@@ -107,20 +108,6 @@ public:
     service_.destroy(impl_);
   }
 
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the strand.
-  /**
-   * This function may be used to obtain the io_service object that the strand
-   * uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A reference to the io_service object that the strand will use to
-   * dispatch handlers. Ownership is not transferred to the caller.
-   */
-  boost::asio::io_service& io_service()
-  {
-    return service_.get_io_service();
-  }
-
   /// Get the io_service associated with the strand.
   /**
    * This function may be used to obtain the io_service object that the strand
@@ -153,10 +140,14 @@ public:
    * handler object as required. The function signature of the handler must be:
    * @code void handler(); @endcode
    */
-  template <typename Handler>
-  void dispatch(Handler handler)
+  template <typename CompletionHandler>
+  void dispatch(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
   {
-    service_.dispatch(impl_, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a CompletionHandler.
+    BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+
+    service_.dispatch(impl_, BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
   }
 
   /// Request the strand to invoke the given handler and return
@@ -175,10 +166,14 @@ public:
    * handler object as required. The function signature of the handler must be:
    * @code void handler(); @endcode
    */
-  template <typename Handler>
-  void post(Handler handler)
+  template <typename CompletionHandler>
+  void post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
   {
-    service_.post(impl_, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a CompletionHandler.
+    BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+
+    service_.post(impl_, BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
   }
 
   /// Create a new handler that automatically dispatches the wrapped handler
diff --git a/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp b/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
index 40d5e18..6b02153 100644
--- a/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
@@ -68,11 +68,18 @@ public:
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native socket type.
+  /// (Deprecated: Use native_handle_type.) The native socket type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_type native_type;
+  typedef typename service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native socket type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new stream socket service for the specified io_service.
@@ -83,18 +90,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new stream socket implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new stream socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another stream socket implementation.
+  void move_assign(implementation_type& impl,
+      stream_socket_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a stream socket implementation.
   void destroy(implementation_type& impl)
   {
@@ -114,7 +132,7 @@ public:
 
   /// Assign an existing native socket to a stream socket.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_type& native_socket,
+      const protocol_type& protocol, const native_handle_type& native_socket,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_socket, ec);
@@ -133,10 +151,16 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native socket implementation.
+  /// (Deprecated: Use native_handle().) Get the native socket implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native socket implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
@@ -177,9 +201,11 @@ public:
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, ConnectHandler handler)
+      const endpoint_type& peer_endpoint,
+      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint, handler);
+    service_impl_.async_connect(impl, peer_endpoint,
+        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
   }
 
   /// Set a socket option.
@@ -206,6 +232,32 @@ public:
     return service_impl_.io_control(impl, command, ec);
   }
 
+  /// Gets the non-blocking mode of the socket.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.non_blocking(impl, mode, ec);
+  }
+
+  /// Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return service_impl_.native_non_blocking(impl);
+  }
+
+  /// Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    return service_impl_.native_non_blocking(impl, mode, ec);
+  }
+
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
@@ -240,9 +292,11 @@ public:
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_send(implementation_type& impl,
       const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send(impl, buffers, flags, handler);
+    service_impl_.async_send(impl, buffers, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data from the peer.
@@ -258,12 +312,20 @@ public:
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
+      socket_base::message_flags flags,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive(impl, buffers, flags, handler);
+    service_impl_.async_receive(impl, buffers, flags,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/version.hpp b/3rdParty/Boost/src/boost/asio/version.hpp
index 9ef5ab5..ccaa58b 100644
--- a/3rdParty/Boost/src/boost/asio/version.hpp
+++ b/3rdParty/Boost/src/boost/asio/version.hpp
@@ -18,6 +18,6 @@
 // BOOST_ASIO_VERSION % 100 is the sub-minor version
 // BOOST_ASIO_VERSION / 100 % 1000 is the minor version
 // BOOST_ASIO_VERSION / 100000 is the major version
-#define BOOST_ASIO_VERSION 100409 // 1.4.9
+#define BOOST_ASIO_VERSION 100600 // 1.6.0
 
 #endif // BOOST_ASIO_VERSION_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
index aedd79a..07a788a 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
@@ -45,8 +45,12 @@ class basic_handle
   : public basic_io_object<HandleService>
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// handle.
+  typedef typename HandleService::native_handle_type native_type;
+
   /// The native representation of a handle.
-  typedef typename HandleService::native_type native_type;
+  typedef typename HandleService::native_handle_type native_handle_type;
 
   /// A basic_handle is always the lowest layer.
   typedef basic_handle<HandleService> lowest_layer_type;
@@ -70,18 +74,51 @@ public:
    * @param io_service The io_service object that the handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    *
-   * @param native_handle A native handle.
+   * @param handle A native handle.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_handle(boost::asio::io_service& io_service,
-      const native_type& native_handle)
+      const native_handle_type& handle)
     : basic_io_object<HandleService>(io_service)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, native_handle, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_handle from another.
+  /**
+   * This constructor moves a handle from one object to another.
+   *
+   * @param other The other basic_handle object from which the move will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_handle(io_service&) constructor.
+   */
+  basic_handle(basic_handle&& other)
+    : basic_io_object<HandleService>(
+        BOOST_ASIO_MOVE_CAST(basic_handle)(other))
+  {
+  }
+
+  /// Move-assign a basic_handle from another.
+  /**
+   * This assignment operator moves a handle from one object to another.
+   *
+   * @param other The other basic_handle object from which the move will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_handle(io_service&) constructor.
+   */
+  basic_handle& operator=(basic_handle&& other)
+  {
+    basic_io_object<HandleService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_handle)(other));
+    return *this;
   }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Get a reference to the lowest layer.
   /**
@@ -115,35 +152,35 @@ public:
   /*
    * This function opens the handle to hold an existing native handle.
    *
-   * @param native_handle A native handle.
+   * @param handle A native handle.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const native_type& native_handle)
+  void assign(const native_handle_type& handle)
   {
     boost::system::error_code ec;
-    this->service.assign(this->implementation, native_handle, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    boost::asio::detail::throw_error(ec, "assign");
   }
 
   /// Assign an existing native handle to the handle.
   /*
    * This function opens the handle to hold an existing native handle.
    *
-   * @param native_handle A native handle.
+   * @param handle A native handle.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  boost::system::error_code assign(const native_type& native_handle,
+  boost::system::error_code assign(const native_handle_type& handle,
       boost::system::error_code& ec)
   {
-    return this->service.assign(this->implementation, native_handle, ec);
+    return this->get_service().assign(this->get_implementation(), handle, ec);
   }
 
   /// Determine whether the handle is open.
   bool is_open() const
   {
-    return this->service.is_open(this->implementation);
+    return this->get_service().is_open(this->get_implementation());
   }
 
   /// Close the handle.
@@ -157,8 +194,8 @@ public:
   void close()
   {
     boost::system::error_code ec;
-    this->service.close(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().close(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
   }
 
   /// Close the handle.
@@ -171,10 +208,10 @@ public:
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->service.close(this->implementation, ec);
+    return this->get_service().close(this->get_implementation(), ec);
   }
 
-  /// Get the native handle representation.
+  /// (Deprecated: Use native_handle().) Get the native handle representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * handle. This is intended to allow access to native handle functionality
@@ -182,7 +219,18 @@ public:
    */
   native_type native()
   {
-    return this->service.native(this->implementation);
+    return this->get_service().native_handle(this->get_implementation());
+  }
+
+  /// Get the native handle representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * handle. This is intended to allow access to native handle functionality
+   * that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return this->get_service().native_handle(this->get_implementation());
   }
 
   /// Cancel all asynchronous operations associated with the handle.
@@ -196,8 +244,8 @@ public:
   void cancel()
   {
     boost::system::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
   }
 
   /// Cancel all asynchronous operations associated with the handle.
@@ -210,7 +258,7 @@ public:
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    return this->get_service().cancel(this->get_implementation(), ec);
   }
 
 protected:
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp
index 207e414..7e0b9db 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp
@@ -21,6 +21,7 @@
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/windows/basic_handle.hpp>
@@ -46,8 +47,13 @@ class basic_random_access_handle
   : public basic_handle<RandomAccessHandleService>
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// handle.
+  typedef typename RandomAccessHandleService::native_handle_type native_type;
+
   /// The native representation of a handle.
-  typedef typename RandomAccessHandleService::native_type native_type;
+  typedef typename RandomAccessHandleService::native_handle_type
+    native_handle_type;
 
   /// Construct a basic_random_access_handle without opening it.
   /**
@@ -72,16 +78,54 @@ public:
    * use to dispatch handlers for any asynchronous operations performed on the
    * handle.
    *
-   * @param native_handle The new underlying handle implementation.
+   * @param handle The new underlying handle implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_random_access_handle(boost::asio::io_service& io_service,
-      const native_type& native_handle)
-    : basic_handle<RandomAccessHandleService>(io_service, native_handle)
+      const native_handle_type& handle)
+    : basic_handle<RandomAccessHandleService>(io_service, handle)
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_random_access_handle from another.
+  /**
+   * This constructor moves a random-access handle from one object to another.
+   *
+   * @param other The other basic_random_access_handle object from which the
+   * move will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_handle(io_service&)
+   * constructor.
+   */
+  basic_random_access_handle(basic_random_access_handle&& other)
+    : basic_handle<RandomAccessHandleService>(
+        BOOST_ASIO_MOVE_CAST(basic_random_access_handle)(other))
+  {
+  }
+
+  /// Move-assign a basic_random_access_handle from another.
+  /**
+   * This assignment operator moves a random-access handle from one object to
+   * another.
+   *
+   * @param other The other basic_random_access_handle object from which the
+   * move will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_handle(io_service&)
+   * constructor.
+   */
+  basic_random_access_handle& operator=(basic_random_access_handle&& other)
+  {
+    basic_handle<RandomAccessHandleService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_random_access_handle)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Write some data to the handle at the specified offset.
   /**
    * This function is used to write data to the random-access handle. The
@@ -116,9 +160,9 @@ public:
       const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.write_some_at(
-        this->implementation, offset, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().write_some_at(
+        this->get_implementation(), offset, buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some_at");
     return s;
   }
 
@@ -144,8 +188,8 @@ public:
   std::size_t write_some_at(boost::uint64_t offset,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
-    return this->service.write_some_at(
-        this->implementation, offset, buffers, ec);
+    return this->get_service().write_some_at(
+        this->get_implementation(), offset, buffers, ec);
   }
 
   /// Start an asynchronous write at the specified offset.
@@ -187,10 +231,15 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some_at(boost::uint64_t offset,
-      const ConstBufferSequence& buffers, WriteHandler handler)
+      const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_write_some_at(
-        this->implementation, offset, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_write_some_at(this->get_implementation(),
+        offset, buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the handle at the specified offset.
@@ -228,9 +277,9 @@ public:
       const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.read_some_at(
-        this->implementation, offset, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().read_some_at(
+        this->get_implementation(), offset, buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some_at");
     return s;
   }
 
@@ -257,8 +306,8 @@ public:
   std::size_t read_some_at(boost::uint64_t offset,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
-    return this->service.read_some_at(
-        this->implementation, offset, buffers, ec);
+    return this->get_service().read_some_at(
+        this->get_implementation(), offset, buffers, ec);
   }
 
   /// Start an asynchronous read at the specified offset.
@@ -301,10 +350,15 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some_at(boost::uint64_t offset,
-      const MutableBufferSequence& buffers, ReadHandler handler)
+      const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_read_some_at(
-        this->implementation, offset, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_read_some_at(this->get_implementation(),
+        offset, buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
index 105b041..35209dc 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
@@ -21,10 +21,11 @@
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/windows/basic_handle.hpp>
 #include <boost/asio/windows/stream_handle_service.hpp>
-#include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -49,8 +50,12 @@ class basic_stream_handle
   : public basic_handle<StreamHandleService>
 {
 public:
+  /// (Deprecated: Use native_handle_type.) The native representation of a
+  /// handle.
+  typedef typename StreamHandleService::native_handle_type native_type;
+
   /// The native representation of a handle.
-  typedef typename StreamHandleService::native_type native_type;
+  typedef typename StreamHandleService::native_handle_type native_handle_type;
 
   /// Construct a basic_stream_handle without opening it.
   /**
@@ -74,16 +79,52 @@ public:
    * @param io_service The io_service object that the stream handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    *
-   * @param native_handle The new underlying handle implementation.
+   * @param handle The new underlying handle implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_handle(boost::asio::io_service& io_service,
-      const native_type& native_handle)
-    : basic_handle<StreamHandleService>(io_service, native_handle)
+      const native_handle_type& handle)
+    : basic_handle<StreamHandleService>(io_service, handle)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_stream_handle from another.
+  /**
+   * This constructor moves a stream handle from one object to another.
+   *
+   * @param other The other basic_stream_handle object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_handle(io_service&) constructor.
+   */
+  basic_stream_handle(basic_stream_handle&& other)
+    : basic_handle<StreamHandleService>(
+        BOOST_ASIO_MOVE_CAST(basic_stream_handle)(other))
   {
   }
 
+  /// Move-assign a basic_stream_handle from another.
+  /**
+   * This assignment operator moves a stream handle from one object to
+   * another.
+   *
+   * @param other The other basic_stream_handle object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_handle(io_service&) constructor.
+   */
+  basic_stream_handle& operator=(basic_stream_handle&& other)
+  {
+    basic_handle<StreamHandleService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_stream_handle)(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Write some data to the handle.
   /**
    * This function is used to write data to the stream handle. The function call
@@ -115,8 +156,9 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.write_some(this->implementation, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
     return s;
   }
 
@@ -140,7 +182,8 @@ public:
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.write_some(this->implementation, buffers, ec);
+    return this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
   }
 
   /// Start an asynchronous write.
@@ -180,9 +223,14 @@ public:
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    this->service.async_write_some(this->implementation, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a WriteHandler.
+    BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    this->get_service().async_write_some(this->get_implementation(),
+        buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the handle.
@@ -217,8 +265,9 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->service.read_some(this->implementation, buffers, ec);
-    boost::asio::detail::throw_error(ec);
+    std::size_t s = this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
     return s;
   }
 
@@ -243,7 +292,8 @@ public:
   std::size_t read_some(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->service.read_some(this->implementation, buffers, ec);
+    return this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
   }
 
   /// Start an asynchronous read.
@@ -284,9 +334,14 @@ public:
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    this->service.async_read_some(this->implementation, buffers, handler);
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ReadHandler.
+    BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    this->get_service().async_read_some(this->get_implementation(),
+        buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp b/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
index c9b1889..e885892 100644
--- a/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
@@ -51,8 +51,9 @@ public:
 
   /// Construct an overlapped_ptr to contain the specified handler.
   template <typename Handler>
-  explicit overlapped_ptr(boost::asio::io_service& io_service, Handler handler)
-    : impl_(io_service, handler)
+  explicit overlapped_ptr(boost::asio::io_service& io_service,
+      BOOST_ASIO_MOVE_ARG(Handler) handler)
+    : impl_(io_service, BOOST_ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -70,9 +71,10 @@ public:
   /// Reset to contain the specified handler, freeing any current OVERLAPPED
   /// object.
   template <typename Handler>
-  void reset(boost::asio::io_service& io_service, Handler handler)
+  void reset(boost::asio::io_service& io_service,
+      BOOST_ASIO_MOVE_ARG(Handler) handler)
   {
-    impl_.reset(io_service, handler);
+    impl_.reset(io_service, BOOST_ASIO_MOVE_CAST(Handler)(handler));
   }
 
   /// Get the contained OVERLAPPED object.
diff --git a/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp b/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp
index 08cb561..8da3564 100644
--- a/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp
@@ -59,11 +59,18 @@ public:
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native handle type.
+  /// (Deprecated: Use native_handle_type.) The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_type native_type;
+  typedef service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native handle type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new random-access handle service for the specified io_service.
@@ -74,18 +81,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new random-access handle implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new random-access handle implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another random-access handle implementation.
+  void move_assign(implementation_type& impl,
+      random_access_handle_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a random-access handle implementation.
   void destroy(implementation_type& impl)
   {
@@ -94,9 +112,9 @@ public:
 
   /// Assign an existing native handle to a random-access handle.
   boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_handle, boost::system::error_code& ec)
+      const native_handle_type& handle, boost::system::error_code& ec)
   {
-    return service_impl_.assign(impl, native_handle, ec);
+    return service_impl_.assign(impl, handle, ec);
   }
 
   /// Determine whether the handle is open.
@@ -112,10 +130,16 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native handle implementation.
+  /// (Deprecated: Use native_handle().) Get the native handle implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native handle implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
@@ -135,10 +159,12 @@ public:
 
   /// Start an asynchronous write at the specified offset.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some_at(implementation_type& impl, boost::uint64_t offset,
-      const ConstBufferSequence& buffers, WriteHandler handler)
+  void async_write_some_at(implementation_type& impl,
+      boost::uint64_t offset, const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some_at(impl, offset, buffers, handler);
+    service_impl_.async_write_some_at(impl, offset, buffers,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the specified offset.
@@ -151,13 +177,21 @@ public:
 
   /// Start an asynchronous read at the specified offset.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some_at(implementation_type& impl, boost::uint64_t offset,
-      const MutableBufferSequence& buffers, ReadHandler handler)
+  void async_read_some_at(implementation_type& impl,
+      boost::uint64_t offset, const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some_at(impl, offset, buffers, handler);
+    service_impl_.async_read_some_at(impl, offset, buffers,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp b/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
index 418ea1e..828dc99 100644
--- a/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
@@ -57,11 +57,18 @@ public:
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// The native handle type.
+  /// (Deprecated: Use native_handle_type.) The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_type native_type;
+  typedef service_impl_type::native_handle_type native_type;
+#endif
+
+  /// The native handle type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
   /// Construct a new stream handle service for the specified io_service.
@@ -71,18 +78,29 @@ public:
   {
   }
 
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   /// Construct a new stream handle implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new stream handle implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another stream handle implementation.
+  void move_assign(implementation_type& impl,
+      stream_handle_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a stream handle implementation.
   void destroy(implementation_type& impl)
   {
@@ -91,9 +109,9 @@ public:
 
   /// Assign an existing native handle to a stream handle.
   boost::system::error_code assign(implementation_type& impl,
-      const native_type& native_handle, boost::system::error_code& ec)
+      const native_handle_type& handle, boost::system::error_code& ec)
   {
-    return service_impl_.assign(impl, native_handle, ec);
+    return service_impl_.assign(impl, handle, ec);
   }
 
   /// Determine whether the handle is open.
@@ -109,10 +127,16 @@ public:
     return service_impl_.close(impl, ec);
   }
 
-  /// Get the native handle implementation.
+  /// (Deprecated: Use native_handle().) Get the native handle implementation.
   native_type native(implementation_type& impl)
   {
-    return service_impl_.native(impl);
+    return service_impl_.native_handle(impl);
+  }
+
+  /// Get the native handle implementation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return service_impl_.native_handle(impl);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
@@ -133,9 +157,11 @@ public:
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, WriteHandler handler)
+      const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some(impl, buffers, handler);
+    service_impl_.async_write_some(impl, buffers,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the stream.
@@ -149,12 +175,20 @@ public:
   /// Start an asynchronous read.
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, ReadHandler handler)
+      const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some(impl, buffers, handler);
+    service_impl_.async_read_some(impl, buffers,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
 private:
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/write.hpp b/3rdParty/Boost/src/boost/asio/write.hpp
index 537a8d6..e8aee08 100644
--- a/3rdParty/Boost/src/boost/asio/write.hpp
+++ b/3rdParty/Boost/src/boost/asio/write.hpp
@@ -71,6 +71,46 @@ namespace asio {
 template <typename SyncWriteStream, typename ConstBufferSequence>
 std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
 
+/// Write all of the supplied data to a stream before returning.
+/**
+ * This function is used to write a certain number of bytes of data to a stream.
+ * The call will block until one of the following conditions is true:
+ *
+ * @li All of the data in the supplied buffers has been written. That is, the
+ * bytes transferred is equal to the sum of the buffer sizes.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * write_some function.
+ *
+ * @param s The stream to which the data is to be written. The type must support
+ * the SyncWriteStream concept.
+ *
+ * @param buffers One or more buffers containing the data to be written. The sum
+ * of the buffer sizes indicates the maximum number of bytes to write to the
+ * stream.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @par Example
+ * To write a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::write(s, boost::asio::buffer(data, size), ec); @endcode
+ * See the @ref buffer documentation for information on writing multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::write(
+ *     s, buffers,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncWriteStream, typename ConstBufferSequence>
+std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    boost::system::error_code& ec);
+
 /// Write a certain amount of data to a stream before returning.
 /**
  * This function is used to write a certain number of bytes of data to a stream.
@@ -197,6 +237,36 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
 template <typename SyncWriteStream, typename Allocator>
 std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
 
+/// Write all of the supplied data to a stream before returning.
+/**
+ * This function is used to write a certain number of bytes of data to a stream.
+ * The call will block until one of the following conditions is true:
+ *
+ * @li All of the data in the supplied basic_streambuf has been written.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * write_some function.
+ *
+ * @param s The stream to which the data is to be written. The type must support
+ * the SyncWriteStream concept.
+ *
+ * @param b The basic_streambuf object from which data will be written.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::write(
+ *     s, b,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncWriteStream, typename Allocator>
+std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec);
+
 /// Write a certain amount of data to a stream before returning.
 /**
  * This function is used to write a certain number of bytes of data to a stream.
@@ -344,7 +414,7 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename WriteHandler>
 void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    WriteHandler handler);
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
@@ -416,7 +486,8 @@ void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
 void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, WriteHandler handler);
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 #if !defined(BOOST_NO_IOSTREAM)
 
@@ -463,7 +534,7 @@ void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  */
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
 void async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
-    WriteHandler handler);
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
@@ -523,7 +594,8 @@ void async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
 template <typename AsyncWriteStream, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
 void async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, WriteHandler handler);
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
diff --git a/3rdParty/Boost/src/boost/asio/write_at.hpp b/3rdParty/Boost/src/boost/asio/write_at.hpp
index 9c0c575..f5548d8 100644
--- a/3rdParty/Boost/src/boost/asio/write_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/write_at.hpp
@@ -76,6 +76,51 @@ template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, const ConstBufferSequence& buffers);
 
+/// Write all of the supplied data at the specified offset before returning.
+/**
+ * This function is used to write a certain number of bytes of data to a random
+ * access device at a specified offset. The call will block until one of the
+ * following conditions is true:
+ *
+ * @li All of the data in the supplied buffers has been written. That is, the
+ * bytes transferred is equal to the sum of the buffer sizes.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the device's
+ * write_some_at function.
+ *
+ * @param d The device to which the data is to be written. The type must support
+ * the SyncRandomAccessWriteDevice concept.
+ *
+ * @param offset The offset at which the data will be written.
+ *
+ * @param buffers One or more buffers containing the data to be written. The sum
+ * of the buffer sizes indicates the maximum number of bytes to write to the
+ * device.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @par Example
+ * To write a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::write_at(d, 42,
+ *     boost::asio::buffer(data, size), ec); @endcode
+ * See the @ref buffer documentation for information on writing multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::write_at(
+ *     d, offset, buffers,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
+std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    boost::system::error_code& ec);
+
 /// Write a certain amount of data at a specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
@@ -214,6 +259,40 @@ template <typename SyncRandomAccessWriteDevice, typename Allocator>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, basic_streambuf<Allocator>& b);
 
+/// Write all of the supplied data at the specified offset before returning.
+/**
+ * This function is used to write a certain number of bytes of data to a random
+ * access device at a specified offset. The call will block until one of the
+ * following conditions is true:
+ *
+ * @li All of the data in the supplied basic_streambuf has been written.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the device's
+ * write_some_at function.
+ *
+ * @param d The device to which the data is to be written. The type must support
+ * the SyncRandomAccessWriteDevice concept.
+ *
+ * @param offset The offset at which the data will be written.
+ *
+ * @param b The basic_streambuf object from which data will be written.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::write_at(
+ *     d, 42, b,
+ *     boost::asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncRandomAccessWriteDevice, typename Allocator>
+std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec);
+
 /// Write a certain amount of data at a specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
@@ -367,7 +446,8 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
-    const ConstBufferSequence& buffers, WriteHandler handler);
+    const ConstBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 /// Start an asynchronous operation to write a certain amount of data at the
 /// specified offset.
@@ -439,7 +519,8 @@ template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, WriteHandler handler);
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 #if !defined(BOOST_NO_IOSTREAM)
 
@@ -486,7 +567,7 @@ void async_write_at(AsyncRandomAccessWriteDevice& d,
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
-    basic_streambuf<Allocator>& b, WriteHandler handler);
+    basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 /// Start an asynchronous operation to write a certain amount of data at the
 /// specified offset.
@@ -546,7 +627,7 @@ template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
-    WriteHandler handler);
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
author	Kevin Smith <git@kismith.co.uk>	2012-08-02 20:41:55 (GMT)
committer	Kevin Smith <git@kismith.co.uk>	2012-08-02 21:03:09 (GMT)
commit	d5ace22054203c7989691ae8b3fa4e4784d1b57e (patch)
tree	64d400cdb10644967df183d0f202fcbf8160a773 /3rdParty/Boost/src/boost/asio
parent	6f26d9aa86f0909af13b23b1a925b8d492e74154 (diff)
download	swift-contrib-d5ace22054203c7989691ae8b3fa4e4784d1b57e.zip swift-contrib-d5ace22054203c7989691ae8b3fa4e4784d1b57e.tar.bz2