diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2823f6cf..33560394 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -259,7 +259,8 @@ configure_file (
 
 # Compiler flags
 # Add a few for release builds (MAKE_BUILD_TYPE=RELEASE)
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wall -fomit-frame-pointer -ffast-math -funroll-loops -march=k8 -mmmx -msse -mfpmath=sse -msse2 -mfpmath=sse")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -pipe -Wall -fomit-frame-pointer -ffast-math -funroll-loops -march=native -mmmx -m3dnow -msse -msse2 -msse3 -mfpmath=sse")
+message(STATUS "CMAKE Release Flags: " ${CMAKE_CXX_FLAGS_RELEASE})
 
 # Compile executables
 set(EXECUTABLES
diff --git a/extern/include/asio.hpp b/extern/include/asio.hpp
index 59083da3..3356df00 100644
--- a/extern/include/asio.hpp
+++ b/extern/include/asio.hpp
@@ -2,7 +2,7 @@
 // asio.hpp
 // ~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/async_result.hpp"
 #include "asio/basic_datagram_socket.hpp"
 #include "asio/basic_deadline_timer.hpp"
@@ -29,6 +31,7 @@
 #include "asio/basic_stream_socket.hpp"
 #include "asio/basic_streambuf.hpp"
 #include "asio/basic_waitable_timer.hpp"
+#include "asio/bind_executor.hpp"
 #include "asio/buffer.hpp"
 #include "asio/buffered_read_stream_fwd.hpp"
 #include "asio/buffered_read_stream.hpp"
@@ -43,8 +46,13 @@
 #include "asio/datagram_socket_service.hpp"
 #include "asio/deadline_timer_service.hpp"
 #include "asio/deadline_timer.hpp"
+#include "asio/defer.hpp"
+#include "asio/dispatch.hpp"
 #include "asio/error.hpp"
 #include "asio/error_code.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/executor.hpp"
+#include "asio/executor_work_guard.hpp"
 #include "asio/generic/basic_endpoint.hpp"
 #include "asio/generic/datagram_protocol.hpp"
 #include "asio/generic/raw_protocol.hpp"
@@ -54,10 +62,19 @@
 #include "asio/handler_continuation_hook.hpp"
 #include "asio/handler_invoke_hook.hpp"
 #include "asio/handler_type.hpp"
+#include "asio/high_resolution_timer.hpp"
+#include "asio/io_context.hpp"
+#include "asio/io_context_strand.hpp"
 #include "asio/io_service.hpp"
+#include "asio/io_service_strand.hpp"
 #include "asio/ip/address.hpp"
 #include "asio/ip/address_v4.hpp"
+#include "asio/ip/address_v4_iterator.hpp"
+#include "asio/ip/address_v4_range.hpp"
 #include "asio/ip/address_v6.hpp"
+#include "asio/ip/address_v6_iterator.hpp"
+#include "asio/ip/address_v6_range.hpp"
+#include "asio/ip/bad_address_cast.hpp"
 #include "asio/ip/basic_endpoint.hpp"
 #include "asio/ip/basic_resolver.hpp"
 #include "asio/ip/basic_resolver_entry.hpp"
@@ -66,24 +83,29 @@
 #include "asio/ip/host_name.hpp"
 #include "asio/ip/icmp.hpp"
 #include "asio/ip/multicast.hpp"
+#include "asio/ip/resolver_base.hpp"
 #include "asio/ip/resolver_query_base.hpp"
 #include "asio/ip/resolver_service.hpp"
 #include "asio/ip/tcp.hpp"
 #include "asio/ip/udp.hpp"
 #include "asio/ip/unicast.hpp"
 #include "asio/ip/v6_only.hpp"
+#include "asio/is_executor.hpp"
 #include "asio/is_read_buffered.hpp"
 #include "asio/is_write_buffered.hpp"
 #include "asio/local/basic_endpoint.hpp"
 #include "asio/local/connect_pair.hpp"
 #include "asio/local/datagram_protocol.hpp"
 #include "asio/local/stream_protocol.hpp"
+#include "asio/packaged_task.hpp"
 #include "asio/placeholders.hpp"
 #include "asio/posix/basic_descriptor.hpp"
 #include "asio/posix/basic_stream_descriptor.hpp"
+#include "asio/posix/descriptor.hpp"
 #include "asio/posix/descriptor_base.hpp"
 #include "asio/posix/stream_descriptor.hpp"
 #include "asio/posix/stream_descriptor_service.hpp"
+#include "asio/post.hpp"
 #include "asio/raw_socket_service.hpp"
 #include "asio/read.hpp"
 #include "asio/read_at.hpp"
@@ -96,12 +118,19 @@
 #include "asio/signal_set_service.hpp"
 #include "asio/socket_acceptor_service.hpp"
 #include "asio/socket_base.hpp"
+#include "asio/steady_timer.hpp"
 #include "asio/strand.hpp"
 #include "asio/stream_socket_service.hpp"
 #include "asio/streambuf.hpp"
+#include "asio/system_context.hpp"
 #include "asio/system_error.hpp"
+#include "asio/system_executor.hpp"
+#include "asio/system_timer.hpp"
 #include "asio/thread.hpp"
+#include "asio/thread_pool.hpp"
 #include "asio/time_traits.hpp"
+#include "asio/use_future.hpp"
+#include "asio/uses_executor.hpp"
 #include "asio/version.hpp"
 #include "asio/wait_traits.hpp"
 #include "asio/waitable_timer_service.hpp"
@@ -111,6 +140,7 @@
 #include "asio/windows/basic_stream_handle.hpp"
 #include "asio/windows/object_handle.hpp"
 #include "asio/windows/object_handle_service.hpp"
+#include "asio/windows/overlapped_handle.hpp"
 #include "asio/windows/overlapped_ptr.hpp"
 #include "asio/windows/random_access_handle.hpp"
 #include "asio/windows/random_access_handle_service.hpp"
diff --git a/extern/include/asio/associated_allocator.hpp b/extern/include/asio/associated_allocator.hpp
new file mode 100644
index 00000000..8b488bb3
--- /dev/null
+++ b/extern/include/asio/associated_allocator.hpp
@@ -0,0 +1,131 @@
+//
+// associated_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_ASSOCIATED_ALLOCATOR_HPP
+#define ASIO_ASSOCIATED_ALLOCATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <memory>
+#include "asio/detail/type_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename>
+struct associated_allocator_check
+{
+  typedef void type;
+};
+
+template <typename T, typename E, typename = void>
+struct associated_allocator_impl
+{
+  typedef E type;
+
+  static type get(const T&, const E& e) ASIO_NOEXCEPT
+  {
+    return e;
+  }
+};
+
+template <typename T, typename E>
+struct associated_allocator_impl<T, E,
+  typename associated_allocator_check<typename T::allocator_type>::type>
+{
+  typedef typename T::allocator_type type;
+
+  static type get(const T& t, const E&) ASIO_NOEXCEPT
+  {
+    return t.get_allocator();
+  }
+};
+
+} // namespace detail
+
+/// Traits type used to obtain the allocator associated with an object.
+/**
+ * A program may specialise this traits type if the @c T template parameter in
+ * the specialisation is a user-defined type. The template parameter @c
+ * Allocator shall be a type meeting the Allocator requirements.
+ *
+ * Specialisations shall meet the following requirements, where @c t is a const
+ * reference to an object of type @c T, and @c a is an object of type @c
+ * Allocator.
+ *
+ * @li Provide a nested typedef @c type that identifies a type meeting the
+ * Allocator requirements.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t) and with return type @c type.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t,a) and with return type @c type.
+ */
+template <typename T, typename Allocator = std::allocator<void> >
+struct associated_allocator
+{
+  /// If @c T has a nested type @c allocator_type, <tt>T::allocator_type</tt>.
+  /// Otherwise @c Allocator.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef see_below type;
+#else // defined(GENERATING_DOCUMENTATION)
+  typedef typename detail::associated_allocator_impl<T, Allocator>::type type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// If @c T has a nested type @c allocator_type, returns
+  /// <tt>t.get_allocator()</tt>. Otherwise returns @c a.
+  static type get(const T& t,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return detail::associated_allocator_impl<T, Allocator>::get(t, a);
+  }
+};
+
+/// Helper function to obtain an object's associated allocator.
+/**
+ * @returns <tt>associated_allocator<T>::get(t)</tt>
+ */
+template <typename T>
+inline typename associated_allocator<T>::type
+get_associated_allocator(const T& t) ASIO_NOEXCEPT
+{
+  return associated_allocator<T>::get(t);
+}
+
+/// Helper function to obtain an object's associated allocator.
+/**
+ * @returns <tt>associated_allocator<T, Allocator>::get(t, a)</tt>
+ */
+template <typename T, typename Allocator>
+inline typename associated_allocator<T, Allocator>::type
+get_associated_allocator(const T& t, const Allocator& a) ASIO_NOEXCEPT
+{
+  return associated_allocator<T, Allocator>::get(t, a);
+}
+
+#if defined(ASIO_HAS_ALIAS_TEMPLATES)
+
+template <typename T, typename Allocator = std::allocator<void> >
+using associated_allocator_t
+  = typename associated_allocator<T, Allocator>::type;
+
+#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_ASSOCIATED_ALLOCATOR_HPP
diff --git a/extern/include/asio/associated_executor.hpp b/extern/include/asio/associated_executor.hpp
new file mode 100644
index 00000000..4c5c2078
--- /dev/null
+++ b/extern/include/asio/associated_executor.hpp
@@ -0,0 +1,149 @@
+//
+// associated_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_ASSOCIATED_EXECUTOR_HPP
+#define ASIO_ASSOCIATED_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/is_executor.hpp"
+#include "asio/system_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename>
+struct associated_executor_check
+{
+  typedef void type;
+};
+
+template <typename T, typename E, typename = void>
+struct associated_executor_impl
+{
+  typedef E type;
+
+  static type get(const T&, const E& e) ASIO_NOEXCEPT
+  {
+    return e;
+  }
+};
+
+template <typename T, typename E>
+struct associated_executor_impl<T, E,
+  typename associated_executor_check<typename T::executor_type>::type>
+{
+  typedef typename T::executor_type type;
+
+  static type get(const T& t, const E&) ASIO_NOEXCEPT
+  {
+    return t.get_executor();
+  }
+};
+
+} // namespace detail
+
+/// Traits type used to obtain the executor associated with an object.
+/**
+ * A program may specialise this traits type if the @c T template parameter in
+ * the specialisation is a user-defined type. The template parameter @c
+ * Executor shall be a type meeting the Executor requirements.
+ *
+ * Specialisations shall meet the following requirements, where @c t is a const
+ * reference to an object of type @c T, and @c e is an object of type @c
+ * Executor.
+ *
+ * @li Provide a nested typedef @c type that identifies a type meeting the
+ * Executor requirements.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t) and with return type @c type.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t,e) and with return type @c type.
+ */
+template <typename T, typename Executor = system_executor>
+struct associated_executor
+{
+  /// If @c T has a nested type @c executor_type, <tt>T::executor_type</tt>.
+  /// Otherwise @c Executor.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef see_below type;
+#else // defined(GENERATING_DOCUMENTATION)
+  typedef typename detail::associated_executor_impl<T, Executor>::type type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// If @c T has a nested type @c executor_type, returns
+  /// <tt>t.get_executor()</tt>. Otherwise returns @c ex.
+  static type get(const T& t,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return detail::associated_executor_impl<T, Executor>::get(t, ex);
+  }
+};
+
+/// Helper function to obtain an object's associated executor.
+/**
+ * @returns <tt>associated_executor<T>::get(t)</tt>
+ */
+template <typename T>
+inline typename associated_executor<T>::type
+get_associated_executor(const T& t) ASIO_NOEXCEPT
+{
+  return associated_executor<T>::get(t);
+}
+
+/// Helper function to obtain an object's associated executor.
+/**
+ * @returns <tt>associated_executor<T, Executor>::get(t, ex)</tt>
+ */
+template <typename T, typename Executor>
+inline typename associated_executor<T, Executor>::type
+get_associated_executor(const T& t, const Executor& ex,
+    typename enable_if<is_executor<
+      Executor>::value>::type* = 0) ASIO_NOEXCEPT
+{
+  return associated_executor<T, Executor>::get(t, ex);
+}
+
+/// Helper function to obtain an object's associated executor.
+/**
+ * @returns <tt>associated_executor<T, typename
+ * ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
+ */
+template <typename T, typename ExecutionContext>
+inline typename associated_executor<T,
+  typename ExecutionContext::executor_type>::type
+get_associated_executor(const T& t, ExecutionContext& ctx,
+    typename enable_if<is_convertible<ExecutionContext&,
+      execution_context&>::value>::type* = 0) ASIO_NOEXCEPT
+{
+  return associated_executor<T,
+    typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
+}
+
+#if defined(ASIO_HAS_ALIAS_TEMPLATES)
+
+template <typename T, typename Executor = system_executor>
+using associated_executor_t = typename associated_executor<T, Executor>::type;
+
+#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_ASSOCIATED_EXECUTOR_HPP
diff --git a/extern/include/asio/async_result.hpp b/extern/include/asio/async_result.hpp
index 37e9c2e0..18acdf20 100644
--- a/extern/include/asio/async_result.hpp
+++ b/extern/include/asio/async_result.hpp
@@ -2,7 +2,7 @@
 // async_result.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
 #include "asio/handler_type.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -23,11 +24,94 @@
 namespace asio {
 
 /// An interface for customising the behaviour of an initiating function.
+/**
+ * The async_result traits class is used for determining:
+ *
+ * @li the concrete completion handler type to be called at the end of the
+ * asynchronous operation;
+ *
+ * @li the initiating function return type; and
+ *
+ * @li how the return value of the initiating function is obtained.
+ *
+ * The trait allows the handler and return types to be determined at the point
+ * where the specific completion handler signature is known.
+ *
+ * This template may be specialised for user-defined completion token types.
+ * The primary template assumes that the CompletionToken is the completion
+ * handler.
+ */
+#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+template <typename CompletionToken, typename Signature>
+#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+template <typename CompletionToken, typename Signature = void>
+#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+class async_result
+{
+public:
+#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+  /// The concrete completion handler type for the specific signature.
+  typedef CompletionToken completion_handler_type;
+
+  /// The return type of the initiating function.
+  typedef void return_type;
+#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+  // For backward compatibility, determine the concrete completion handler type
+  // by using the legacy handler_type trait.
+  typedef typename handler_type<CompletionToken, Signature>::type
+    completion_handler_type;
+
+  // For backward compatibility, determine the initiating function return type
+  // using the legacy single-parameter version of async_result.
+  typedef typename async_result<completion_handler_type>::type return_type;
+#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+
+  /// Construct an async result from a given handler.
+  /**
+   * When using a specalised async_result, the constructor has an opportunity
+   * to initialise some state associated with the completion handler, which is
+   * then returned from the initiating function.
+   */
+  explicit async_result(completion_handler_type& h)
+#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+    // No data members to initialise.
+#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+    : legacy_result_(h)
+#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+  {
+    (void)h;
+  }
+
+  /// Obtain the value to be returned from the initiating function.
+  return_type get()
+  {
+#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+    // Nothing to do.
+#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+    return legacy_result_.get();
+#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+  }
+
+private:
+  async_result(const async_result&) ASIO_DELETED;
+  async_result& operator=(const async_result&) ASIO_DELETED;
+
+#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+  // No data members.
+#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+  async_result<completion_handler_type> legacy_result_;
+#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+/// (Deprecated: Use two-parameter version of async_result.) An interface for
+/// customising the behaviour of an initiating function.
 /**
  * This template may be specialised for user-defined handler types.
  */
 template <typename Handler>
-class async_result
+class async_result<Handler>
 {
 public:
   /// The return type of the initiating function.
@@ -49,29 +133,65 @@ class async_result
   }
 };
 
-namespace detail {
+#endif // !defined(ASIO_NO_DEPRECATED)
 
-// Helper template to deduce the true type of a handler, capture a local copy
-// of the handler, and then create an async_result for the handler.
-template <typename Handler, typename Signature>
-struct async_result_init
+/// Helper template to deduce the handler type from a CompletionToken, capture
+/// a local copy of the handler, and then create an async_result for the
+/// handler.
+template <typename CompletionToken, typename Signature>
+struct async_completion
 {
-  explicit async_result_init(ASIO_MOVE_ARG(Handler) orig_handler)
-    : handler(ASIO_MOVE_CAST(Handler)(orig_handler)),
-      result(handler)
+  /// The real handler type to be used for the asynchronous operation.
+  typedef typename asio::async_result<
+    typename decay<CompletionToken>::type,
+      Signature>::completion_handler_type completion_handler_type;
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Constructor.
+  /**
+   * The constructor creates the concrete completion handler and makes the link
+   * between the handler and the asynchronous result.
+   */
+  explicit async_completion(CompletionToken& token)
+    : completion_handler(static_cast<typename conditional<
+        is_same<CompletionToken, completion_handler_type>::value,
+        completion_handler_type&, CompletionToken&&>::type>(token)),
+      result(completion_handler)
+  {
+  }
+#else // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  explicit async_completion(typename decay<CompletionToken>::type& token)
+    : completion_handler(token),
+      result(completion_handler)
   {
   }
 
-  typename handler_type<Handler, Signature>::type handler;
-  async_result<typename handler_type<Handler, Signature>::type> result;
+  explicit async_completion(const typename decay<CompletionToken>::type& token)
+    : completion_handler(token),
+      result(completion_handler)
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// A copy of, or reference to, a real handler object.
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  typename conditional<
+    is_same<CompletionToken, completion_handler_type>::value,
+    completion_handler_type&, completion_handler_type>::type completion_handler;
+#else // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  completion_handler_type completion_handler;
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// The result of the asynchronous operation's initiating function.
+  async_result<typename decay<CompletionToken>::type, Signature> result;
 };
 
-template <typename Handler, typename Signature>
-struct async_result_type_helper
+namespace detail {
+
+template <typename CompletionToken, typename Signature>
+struct async_result_helper
+  : async_result<typename decay<CompletionToken>::type, Signature>
 {
-  typedef typename async_result<
-      typename handler_type<Handler, Signature>::type
-    >::type type;
 };
 
 } // namespace detail
@@ -80,15 +200,22 @@ struct async_result_type_helper
 #include "asio/detail/pop_options.hpp"
 
 #if defined(GENERATING_DOCUMENTATION)
-# define ASIO_INITFN_RESULT_TYPE(h, sig) \
+# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
   void_or_deduced
 #elif defined(_MSC_VER) && (_MSC_VER < 1500)
-# define ASIO_INITFN_RESULT_TYPE(h, sig) \
-  typename ::asio::detail::async_result_type_helper<h, sig>::type
+# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
+  typename ::asio::detail::async_result_helper< \
+    ct, sig>::return_type
+#define ASIO_HANDLER_TYPE(ct, sig) \
+  typename ::asio::detail::async_result_helper< \
+    ct, sig>::completion_handler_type
 #else
-# define ASIO_INITFN_RESULT_TYPE(h, sig) \
+# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
+  typename ::asio::async_result< \
+    typename ::asio::decay<ct>::type, sig>::return_type
+#define ASIO_HANDLER_TYPE(ct, sig) \
   typename ::asio::async_result< \
-    typename ::asio::handler_type<h, sig>::type>::type
+    typename ::asio::decay<ct>::type, sig>::completion_handler_type
 #endif
 
 #endif // ASIO_ASYNC_RESULT_HPP
diff --git a/extern/include/asio/basic_datagram_socket.hpp b/extern/include/asio/basic_datagram_socket.hpp
index cce9fe0d..346cc353 100644
--- a/extern/include/asio/basic_datagram_socket.hpp
+++ b/extern/include/asio/basic_datagram_socket.hpp
@@ -2,7 +2,7 @@
 // basic_datagram_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,12 +18,15 @@
 #include "asio/detail/config.hpp"
 #include <cstddef>
 #include "asio/basic_socket.hpp"
-#include "asio/datagram_socket_service.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/datagram_socket_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -37,18 +40,19 @@ namespace asio {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
-template <typename Protocol,
-    typename DatagramSocketService = datagram_socket_service<Protocol> >
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= datagram_socket_service<Protocol>)>
 class basic_datagram_socket
-  : public basic_socket<Protocol, DatagramSocketService>
+  : public basic_socket<Protocol ASIO_SVC_TARG>
 {
 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_handle_type native_handle_type;
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_socket<
+    Protocol ASIO_SVC_TARG>::native_handle_type native_handle_type;
+#endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -61,12 +65,12 @@ class basic_datagram_socket
    * This constructor creates a datagram socket without opening it. The open()
    * function must be called before data can be sent or received on the socket.
    *
-   * @param io_service The io_service object that the datagram socket will use
+   * @param io_context The io_context object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    */
-  explicit basic_datagram_socket(asio::io_service& io_service)
-    : basic_socket<Protocol, DatagramSocketService>(io_service)
+  explicit basic_datagram_socket(asio::io_context& io_context)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context)
   {
   }
 
@@ -74,7 +78,7 @@ class basic_datagram_socket
   /**
    * This constructor creates and opens a datagram socket.
    *
-   * @param io_service The io_service object that the datagram socket will use
+   * @param io_context The io_context object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
@@ -82,9 +86,9 @@ class basic_datagram_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_datagram_socket(asio::io_service& io_service,
+  basic_datagram_socket(asio::io_context& io_context,
       const protocol_type& protocol)
-    : basic_socket<Protocol, DatagramSocketService>(io_service, protocol)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, protocol)
   {
   }
 
@@ -95,7 +99,7 @@ class basic_datagram_socket
    * 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 datagram socket will use
+   * @param io_context The io_context object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
@@ -104,9 +108,9 @@ class basic_datagram_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_datagram_socket(asio::io_service& io_service,
+  basic_datagram_socket(asio::io_context& io_context,
       const endpoint_type& endpoint)
-    : basic_socket<Protocol, DatagramSocketService>(io_service, endpoint)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, endpoint)
   {
   }
 
@@ -115,7 +119,7 @@ class basic_datagram_socket
    * This constructor creates a datagram socket object to hold an existing
    * native socket.
    *
-   * @param io_service The io_service object that the datagram socket will use
+   * @param io_context The io_context object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
@@ -125,10 +129,10 @@ class basic_datagram_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_datagram_socket(asio::io_service& io_service,
+  basic_datagram_socket(asio::io_context& io_context,
       const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, DatagramSocketService>(
-        io_service, protocol, native_socket)
+    : basic_socket<Protocol ASIO_SVC_TARG>(
+        io_context, protocol, native_socket)
   {
   }
 
@@ -141,11 +145,10 @@ class basic_datagram_socket
    * 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.
+   * constructed using the @c basic_datagram_socket(io_context&) constructor.
    */
   basic_datagram_socket(basic_datagram_socket&& other)
-    : basic_socket<Protocol, DatagramSocketService>(
-        ASIO_MOVE_CAST(basic_datagram_socket)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -158,12 +161,11 @@ class basic_datagram_socket
    * 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.
+   * constructed using the @c basic_datagram_socket(io_context&) constructor.
    */
   basic_datagram_socket& operator=(basic_datagram_socket&& other)
   {
-    basic_socket<Protocol, DatagramSocketService>::operator=(
-        ASIO_MOVE_CAST(basic_datagram_socket)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 
@@ -176,15 +178,13 @@ class basic_datagram_socket
    * 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.
+   * constructed using the @c basic_datagram_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename DatagramSocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   basic_datagram_socket(
-      basic_datagram_socket<Protocol1, DatagramSocketService1>&& other,
+      basic_datagram_socket<Protocol1 ASIO_SVC_TARG1>&& other,
       typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
-    : basic_socket<Protocol, DatagramSocketService>(
-        ASIO_MOVE_CAST2(basic_datagram_socket<
-          Protocol1, DatagramSocketService1>)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -198,20 +198,27 @@ class basic_datagram_socket
    * 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.
+   * constructed using the @c basic_datagram_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename DatagramSocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   typename enable_if<is_convertible<Protocol1, Protocol>::value,
       basic_datagram_socket>::type& operator=(
-        basic_datagram_socket<Protocol1, DatagramSocketService1>&& other)
+        basic_datagram_socket<Protocol1 ASIO_SVC_TARG1>&& other)
   {
-    basic_socket<Protocol, DatagramSocketService>::operator=(
-        ASIO_MOVE_CAST2(basic_datagram_socket<
-          Protocol1, DatagramSocketService1>)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
+  /// Destroys the socket.
+  /**
+   * This function destroys the socket, cancelling any outstanding asynchronous
+   * operations associated with the socket as if by calling @c cancel.
+   */
+  ~basic_datagram_socket()
+  {
+  }
+
   /// Send some data on a connected socket.
   /**
    * This function is used to send data on the datagram socket. The function
@@ -317,7 +324,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected datagram
@@ -342,8 +349,18 @@ class basic_datagram_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(this->get_implementation(),
         buffers, 0, ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous send on a connected socket.
@@ -368,7 +385,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected datagram
@@ -385,8 +402,18 @@ class basic_datagram_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(this->get_implementation(),
         buffers, flags, ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, flags, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Send a datagram to the specified endpoint.
@@ -500,7 +527,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
@@ -525,9 +552,20 @@ class basic_datagram_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send_to(
         this->get_implementation(), buffers, destination, 0,
         ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send_to(
+        this->get_implementation(), buffers, destination, 0,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous send.
@@ -555,7 +593,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   ASIO_INITFN_RESULT_TYPE(WriteHandler,
@@ -568,9 +606,20 @@ class basic_datagram_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send_to(
         this->get_implementation(), buffers, destination, flags,
         ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send_to(
+        this->get_implementation(), buffers, destination, flags,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Receive some data on a connected socket.
@@ -682,7 +731,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
@@ -708,8 +757,18 @@ class basic_datagram_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous receive on a connected socket.
@@ -734,7 +793,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
@@ -751,8 +810,18 @@ class basic_datagram_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(this->get_implementation(),
         buffers, flags, ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, flags, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Receive a datagram with the endpoint of the sender.
@@ -869,7 +938,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
@@ -891,9 +960,20 @@ class basic_datagram_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive_from(
         this->get_implementation(), buffers, sender_endpoint, 0,
         ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, 0,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous receive.
@@ -923,7 +1003,7 @@ class basic_datagram_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   ASIO_INITFN_RESULT_TYPE(ReadHandler,
@@ -936,9 +1016,20 @@ class basic_datagram_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive_from(
         this->get_implementation(), buffers, sender_endpoint, flags,
         ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, flags,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 };
 
diff --git a/extern/include/asio/basic_deadline_timer.hpp b/extern/include/asio/basic_deadline_timer.hpp
index f75b9bda..5b20066d 100644
--- a/extern/include/asio/basic_deadline_timer.hpp
+++ b/extern/include/asio/basic_deadline_timer.hpp
@@ -2,7 +2,7 @@
 // basic_deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,10 +22,17 @@
 
 #include <cstddef>
 #include "asio/basic_io_object.hpp"
-#include "asio/deadline_timer_service.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
+#include "asio/time_traits.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/deadline_timer_service.hpp"
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/detail/deadline_timer_service.hpp"
+# define ASIO_SVC_T detail::deadline_timer_service<TimeTraits>
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 #include "asio/detail/push_options.hpp"
 
@@ -50,7 +57,7 @@ namespace asio {
  * Performing a blocking wait:
  * @code
  * // Construct a timer without setting an expiry time.
- * asio::deadline_timer timer(io_service);
+ * asio::deadline_timer timer(io_context);
  *
  * // Set an expiry time relative to now.
  * timer.expires_from_now(boost::posix_time::seconds(5));
@@ -73,7 +80,7 @@ namespace asio {
  * ...
  *
  * // Construct a timer with an absolute expiry time.
- * asio::deadline_timer timer(io_service,
+ * asio::deadline_timer timer(io_context,
  *     boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
  *
  * // Start an asynchronous wait.
@@ -120,12 +127,15 @@ namespace asio {
  * it contains the value asio::error::operation_aborted.
  */
 template <typename Time,
-    typename TimeTraits = asio::time_traits<Time>,
-    typename TimerService = deadline_timer_service<Time, TimeTraits> >
+    typename TimeTraits = asio::time_traits<Time>
+    ASIO_SVC_TPARAM_DEF2(= deadline_timer_service<Time, TimeTraits>)>
 class basic_deadline_timer
-  : public basic_io_object<TimerService>
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>
 {
 public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
   /// The time traits type.
   typedef TimeTraits traits_type;
 
@@ -141,11 +151,11 @@ class basic_deadline_timer
    * expires_at() or expires_from_now() functions must be called to set an
    * expiry time before the timer can be waited on.
    *
-   * @param io_service The io_service object that the timer will use to dispatch
+   * @param io_context The io_context object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    */
-  explicit basic_deadline_timer(asio::io_service& io_service)
-    : basic_io_object<TimerService>(io_service)
+  explicit basic_deadline_timer(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
   }
 
@@ -153,18 +163,18 @@ class basic_deadline_timer
   /**
    * This constructor creates a timer and sets the expiry time.
    *
-   * @param io_service The io_service object that the timer will use to dispatch
+   * @param io_context The io_context object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    *
    * @param expiry_time The expiry time to be used for the timer, expressed
    * as an absolute time.
    */
-  basic_deadline_timer(asio::io_service& io_service,
+  basic_deadline_timer(asio::io_context& io_context,
       const time_type& expiry_time)
-    : basic_io_object<TimerService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
-    this->service.expires_at(this->implementation, expiry_time, ec);
+    this->get_service().expires_at(this->get_implementation(), expiry_time, ec);
     asio::detail::throw_error(ec, "expires_at");
   }
 
@@ -172,21 +182,105 @@ class basic_deadline_timer
   /**
    * This constructor creates a timer and sets the expiry time.
    *
-   * @param io_service The io_service object that the timer will use to dispatch
+   * @param io_context The io_context object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    *
    * @param expiry_time The expiry time to be used for the timer, relative to
    * now.
    */
-  basic_deadline_timer(asio::io_service& io_service,
+  basic_deadline_timer(asio::io_context& io_context,
       const duration_type& expiry_time)
-    : basic_io_object<TimerService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
-    this->service.expires_from_now(this->implementation, expiry_time, ec);
+    this->get_service().expires_from_now(
+        this->get_implementation(), expiry_time, ec);
     asio::detail::throw_error(ec, "expires_from_now");
   }
 
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_deadline_timer from another.
+  /**
+   * This constructor moves a timer from one object to another.
+   *
+   * @param other The other basic_deadline_timer 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_deadline_timer(io_context&) constructor.
+   */
+  basic_deadline_timer(basic_deadline_timer&& other)
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_deadline_timer from another.
+  /**
+   * This assignment operator moves a timer from one object to another. Cancels
+   * any outstanding asynchronous operations associated with the target object.
+   *
+   * @param other The other basic_deadline_timer 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_deadline_timer(io_context&) constructor.
+   */
+  basic_deadline_timer& operator=(basic_deadline_timer&& other)
+  {
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the timer.
+  /**
+   * This function destroys the timer, cancelling any outstanding asynchronous
+   * wait operations associated with the timer as if by calling @c cancel.
+   */
+  ~basic_deadline_timer()
+  {
+  }
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+  // These functions are provided by basic_io_object<>.
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
   /// Cancel any asynchronous operations that are waiting on the timer.
   /**
    * This function forces the completion of any pending asynchronous wait
@@ -212,7 +306,7 @@ class basic_deadline_timer
   std::size_t cancel()
   {
     asio::error_code ec;
-    std::size_t s = this->service.cancel(this->implementation, ec);
+    std::size_t s = this->get_service().cancel(this->get_implementation(), ec);
     asio::detail::throw_error(ec, "cancel");
     return s;
   }
@@ -241,7 +335,7 @@ class basic_deadline_timer
    */
   std::size_t cancel(asio::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    return this->get_service().cancel(this->get_implementation(), ec);
   }
 
   /// Cancels one asynchronous operation that is waiting on the timer.
@@ -271,7 +365,8 @@ class basic_deadline_timer
   std::size_t cancel_one()
   {
     asio::error_code ec;
-    std::size_t s = this->service.cancel_one(this->implementation, ec);
+    std::size_t s = this->get_service().cancel_one(
+        this->get_implementation(), ec);
     asio::detail::throw_error(ec, "cancel_one");
     return s;
   }
@@ -302,7 +397,7 @@ class basic_deadline_timer
    */
   std::size_t cancel_one(asio::error_code& ec)
   {
-    return this->service.cancel_one(this->implementation, ec);
+    return this->get_service().cancel_one(this->get_implementation(), ec);
   }
 
   /// Get the timer's expiry time as an absolute time.
@@ -312,7 +407,7 @@ class basic_deadline_timer
    */
   time_type expires_at() const
   {
-    return this->service.expires_at(this->implementation);
+    return this->get_service().expires_at(this->get_implementation());
   }
 
   /// Set the timer's expiry time as an absolute time.
@@ -340,8 +435,8 @@ class basic_deadline_timer
   std::size_t expires_at(const time_type& expiry_time)
   {
     asio::error_code ec;
-    std::size_t s = this->service.expires_at(
-        this->implementation, expiry_time, ec);
+    std::size_t s = this->get_service().expires_at(
+        this->get_implementation(), expiry_time, ec);
     asio::detail::throw_error(ec, "expires_at");
     return s;
   }
@@ -371,7 +466,8 @@ class basic_deadline_timer
   std::size_t expires_at(const time_type& expiry_time,
       asio::error_code& ec)
   {
-    return this->service.expires_at(this->implementation, expiry_time, ec);
+    return this->get_service().expires_at(
+        this->get_implementation(), expiry_time, ec);
   }
 
   /// Get the timer's expiry time relative to now.
@@ -381,7 +477,7 @@ class basic_deadline_timer
    */
   duration_type expires_from_now() const
   {
-    return this->service.expires_from_now(this->implementation);
+    return this->get_service().expires_from_now(this->get_implementation());
   }
 
   /// Set the timer's expiry time relative to now.
@@ -409,8 +505,8 @@ class basic_deadline_timer
   std::size_t expires_from_now(const duration_type& expiry_time)
   {
     asio::error_code ec;
-    std::size_t s = this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
+    std::size_t s = this->get_service().expires_from_now(
+        this->get_implementation(), expiry_time, ec);
     asio::detail::throw_error(ec, "expires_from_now");
     return s;
   }
@@ -440,8 +536,8 @@ class basic_deadline_timer
   std::size_t expires_from_now(const duration_type& expiry_time,
       asio::error_code& ec)
   {
-    return this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
+    return this->get_service().expires_from_now(
+        this->get_implementation(), expiry_time, ec);
   }
 
   /// Perform a blocking wait on the timer.
@@ -454,7 +550,7 @@ class basic_deadline_timer
   void wait()
   {
     asio::error_code ec;
-    this->service.wait(this->implementation, ec);
+    this->get_service().wait(this->get_implementation(), ec);
     asio::detail::throw_error(ec, "wait");
   }
 
@@ -467,7 +563,7 @@ class basic_deadline_timer
    */
   void wait(asio::error_code& ec)
   {
-    this->service.wait(this->implementation, ec);
+    this->get_service().wait(this->get_implementation(), ec);
   }
 
   /// Start an asynchronous wait on the timer.
@@ -492,7 +588,7 @@ class basic_deadline_timer
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename WaitHandler>
   ASIO_INITFN_RESULT_TYPE(WaitHandler,
@@ -503,8 +599,18 @@ class basic_deadline_timer
     // not meet the documented type requirements for a WaitHandler.
     ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
 
-    return this->service.async_wait(this->implementation,
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_wait(this->get_implementation(),
         ASIO_MOVE_CAST(WaitHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_wait(this->get_implementation(),
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 };
 
@@ -512,6 +618,10 @@ class basic_deadline_timer
 
 #include "asio/detail/pop_options.hpp"
 
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# undef ASIO_SVC_T
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // defined(ASIO_HAS_BOOST_DATE_TIME)
        // || defined(GENERATING_DOCUMENTATION)
 
diff --git a/extern/include/asio/basic_io_object.hpp b/extern/include/asio/basic_io_object.hpp
index d513cc2e..442e8542 100644
--- a/extern/include/asio/basic_io_object.hpp
+++ b/extern/include/asio/basic_io_object.hpp
@@ -2,7 +2,7 @@
 // basic_io_object.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -34,12 +34,13 @@ namespace detail
     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];
+    static auto asio_service_has_move_eval(T* t, U* u)
+      -> decltype(t->move_construct(*u, *u), char());
+    static char (&asio_service_has_move_eval(...))[2];
 
   public:
     static const bool value =
-      sizeof(service_has_move::eval(
+      sizeof(asio_service_has_move_eval(
         static_cast<service_type*>(0),
         static_cast<implementation_type*>(0))) == 1;
   };
@@ -66,17 +67,43 @@ class basic_io_object
   /// The underlying implementation type of I/O object.
   typedef typename service_type::implementation_type implementation_type;
 
-  /// Get the io_service associated with the object.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
   /**
-   * This function may be used to obtain the io_service object that the I/O
+   * This function may be used to obtain the io_context 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
+   * @return A reference to the io_context object that the I/O object will use
    * to dispatch handlers. Ownership is not transferred to the caller.
    */
-  asio::io_service& get_io_service()
+  asio::io_context& get_io_context()
   {
-    return service.get_io_service();
+    return service_.get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return service_.get_io_context();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// The type of the executor associated with the object.
+  typedef asio::io_context::executor_type executor_type;
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return service_.get_io_context().get_executor();
   }
 
 protected:
@@ -85,10 +112,10 @@ class basic_io_object
    * Performs:
    * @code get_service().construct(get_implementation()); @endcode
    */
-  explicit basic_io_object(asio::io_service& io_service)
-    : service(asio::use_service<IoObjectService>(io_service))
+  explicit basic_io_object(asio::io_context& io_context)
+    : service_(asio::use_service<IoObjectService>(io_context))
   {
-    service.construct(implementation);
+    service_.construct(implementation_);
   }
 
 #if defined(GENERATING_DOCUMENTATION)
@@ -111,6 +138,11 @@ class basic_io_object
    * @note Available only for services that support movability,
    */
   basic_io_object& operator=(basic_io_object&& other);
+
+  /// Perform a converting move-construction of a basic_io_object.
+  template <typename IoObjectService1>
+  basic_io_object(IoObjectService1& other_service,
+      typename IoObjectService1::implementation_type& other_implementation);
 #endif // defined(GENERATING_DOCUMENTATION)
 
   /// Protected destructor to prevent deletion through this type.
@@ -120,47 +152,42 @@ class basic_io_object
    */
   ~basic_io_object()
   {
-    service.destroy(implementation);
+    service_.destroy(implementation_);
   }
 
   /// Get the service associated with the I/O object.
   service_type& get_service()
   {
-    return service;
+    return service_;
   }
 
   /// Get the service associated with the I/O object.
   const service_type& get_service() const
   {
-    return service;
+    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;
-
   /// Get the underlying implementation of the I/O object.
   implementation_type& get_implementation()
   {
-    return implementation;
+    return implementation_;
   }
 
   /// Get the underlying implementation of the I/O object.
   const implementation_type& get_implementation() const
   {
-    return implementation;
+    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&);
+
+  // The service associated with the I/O object.
+  service_type& service_;
+
+  /// The underlying implementation of the I/O object.
+  implementation_type implementation_;
 };
 
 #if defined(ASIO_HAS_MOVE)
@@ -172,33 +199,57 @@ class basic_io_object<IoObjectService, true>
   typedef IoObjectService service_type;
   typedef typename service_type::implementation_type implementation_type;
 
-  asio::io_service& get_io_service()
+#if !defined(ASIO_NO_DEPRECATED)
+  asio::io_context& get_io_context()
+  {
+    return service_->get_io_context();
+  }
+
+  asio::io_context& get_io_service()
   {
-    return service_->get_io_service();
+    return service_->get_io_context();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  typedef asio::io_context::executor_type executor_type;
+
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return service_->get_io_context().get_executor();
   }
 
 protected:
-  explicit basic_io_object(asio::io_service& io_service)
-    : service_(&asio::use_service<IoObjectService>(io_service))
+  explicit basic_io_object(asio::io_context& io_context)
+    : service_(&asio::use_service<IoObjectService>(io_context))
   {
-    service_->construct(implementation);
+    service_->construct(implementation_);
   }
 
   basic_io_object(basic_io_object&& other)
     : service_(&other.get_service())
   {
-    service_->move_construct(implementation, other.implementation);
+    service_->move_construct(implementation_, other.implementation_);
+  }
+
+  template <typename IoObjectService1>
+  basic_io_object(IoObjectService1& other_service,
+      typename IoObjectService1::implementation_type& other_implementation)
+    : service_(&asio::use_service<IoObjectService>(
+          other_service.get_io_context()))
+  {
+    service_->converting_move_construct(implementation_,
+        other_service, other_implementation);
   }
 
   ~basic_io_object()
   {
-    service_->destroy(implementation);
+    service_->destroy(implementation_);
   }
 
   basic_io_object& operator=(basic_io_object&& other)
   {
-    service_->move_assign(implementation,
-        *other.service_, other.implementation);
+    service_->move_assign(implementation_,
+        *other.service_, other.implementation_);
     service_ = other.service_;
     return *this;
   }
@@ -215,21 +266,20 @@ class basic_io_object<IoObjectService, true>
 
   implementation_type& get_implementation()
   {
-    return implementation;
+    return implementation_;
   }
 
   const implementation_type& get_implementation() const
   {
-    return implementation;
+    return implementation_;
   }
 
-  implementation_type implementation;
-
 private:
   basic_io_object(const basic_io_object&);
   void operator=(const basic_io_object&);
 
   IoObjectService* service_;
+  implementation_type implementation_;
 };
 #endif // defined(ASIO_HAS_MOVE)
 
diff --git a/extern/include/asio/basic_raw_socket.hpp b/extern/include/asio/basic_raw_socket.hpp
index ff19b5a3..0de7c776 100644
--- a/extern/include/asio/basic_raw_socket.hpp
+++ b/extern/include/asio/basic_raw_socket.hpp
@@ -2,7 +2,7 @@
 // basic_raw_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,7 +22,10 @@
 #include "asio/detail/throw_error.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/raw_socket_service.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/raw_socket_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 #include "asio/detail/push_options.hpp"
 
@@ -37,18 +40,19 @@ namespace asio {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
-template <typename Protocol,
-    typename RawSocketService = raw_socket_service<Protocol> >
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= raw_socket_service<Protocol>)>
 class basic_raw_socket
-  : public basic_socket<Protocol, RawSocketService>
+  : public basic_socket<Protocol ASIO_SVC_TARG>
 {
 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_handle_type native_handle_type;
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_socket<
+    Protocol ASIO_SVC_TARG>::native_handle_type native_handle_type;
+#endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -61,12 +65,12 @@ class basic_raw_socket
    * This constructor creates a raw socket without opening it. The open()
    * function must be called before data can be sent or received on the socket.
    *
-   * @param io_service The io_service object that the raw socket will use
+   * @param io_context The io_context object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    */
-  explicit basic_raw_socket(asio::io_service& io_service)
-    : basic_socket<Protocol, RawSocketService>(io_service)
+  explicit basic_raw_socket(asio::io_context& io_context)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context)
   {
   }
 
@@ -74,7 +78,7 @@ class basic_raw_socket
   /**
    * This constructor creates and opens a raw socket.
    *
-   * @param io_service The io_service object that the raw socket will use
+   * @param io_context The io_context object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
@@ -82,9 +86,9 @@ class basic_raw_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_raw_socket(asio::io_service& io_service,
+  basic_raw_socket(asio::io_context& io_context,
       const protocol_type& protocol)
-    : basic_socket<Protocol, RawSocketService>(io_service, protocol)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, protocol)
   {
   }
 
@@ -95,7 +99,7 @@ class basic_raw_socket
    * 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 raw socket will use
+   * @param io_context The io_context object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
@@ -104,9 +108,9 @@ class basic_raw_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_raw_socket(asio::io_service& io_service,
+  basic_raw_socket(asio::io_context& io_context,
       const endpoint_type& endpoint)
-    : basic_socket<Protocol, RawSocketService>(io_service, endpoint)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, endpoint)
   {
   }
 
@@ -115,7 +119,7 @@ class basic_raw_socket
    * This constructor creates a raw socket object to hold an existing
    * native socket.
    *
-   * @param io_service The io_service object that the raw socket will use
+   * @param io_context The io_context object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
@@ -125,10 +129,10 @@ class basic_raw_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_raw_socket(asio::io_service& io_service,
+  basic_raw_socket(asio::io_context& io_context,
       const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, RawSocketService>(
-        io_service, protocol, native_socket)
+    : basic_socket<Protocol ASIO_SVC_TARG>(
+        io_context, protocol, native_socket)
   {
   }
 
@@ -141,11 +145,10 @@ class basic_raw_socket
    * 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.
+   * constructed using the @c basic_raw_socket(io_context&) constructor.
    */
   basic_raw_socket(basic_raw_socket&& other)
-    : basic_socket<Protocol, RawSocketService>(
-        ASIO_MOVE_CAST(basic_raw_socket)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -157,12 +160,11 @@ class basic_raw_socket
    * 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.
+   * constructed using the @c basic_raw_socket(io_context&) constructor.
    */
   basic_raw_socket& operator=(basic_raw_socket&& other)
   {
-    basic_socket<Protocol, RawSocketService>::operator=(
-        ASIO_MOVE_CAST(basic_raw_socket)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 
@@ -174,14 +176,12 @@ class basic_raw_socket
    * 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.
+   * constructed using the @c basic_raw_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename RawSocketService1>
-  basic_raw_socket(basic_raw_socket<Protocol1, RawSocketService1>&& other,
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
+  basic_raw_socket(basic_raw_socket<Protocol1 ASIO_SVC_TARG1>&& other,
       typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
-    : basic_socket<Protocol, RawSocketService>(
-        ASIO_MOVE_CAST2(basic_raw_socket<
-          Protocol1, RawSocketService1>)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -193,20 +193,27 @@ class basic_raw_socket
    * 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.
+   * constructed using the @c basic_raw_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename RawSocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   typename enable_if<is_convertible<Protocol1, Protocol>::value,
       basic_raw_socket>::type& operator=(
-        basic_raw_socket<Protocol1, RawSocketService1>&& other)
+        basic_raw_socket<Protocol1 ASIO_SVC_TARG1>&& other)
   {
-    basic_socket<Protocol, RawSocketService>::operator=(
-        ASIO_MOVE_CAST2(basic_raw_socket<
-          Protocol1, RawSocketService1>)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
+  /// Destroys the socket.
+  /**
+   * This function destroys the socket, cancelling any outstanding asynchronous
+   * operations associated with the socket as if by calling @c cancel.
+   */
+  ~basic_raw_socket()
+  {
+  }
+
   /// Send some data on a connected socket.
   /**
    * This function is used to send data on the raw socket. The function call
@@ -309,7 +316,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected raw
@@ -334,8 +341,18 @@ class basic_raw_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(this->get_implementation(),
         buffers, 0, ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous send on a connected socket.
@@ -360,7 +377,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected raw
@@ -377,8 +394,18 @@ class basic_raw_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(this->get_implementation(),
         buffers, flags, ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, flags, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Send raw data to the specified endpoint.
@@ -492,7 +519,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
@@ -517,8 +544,18 @@ class basic_raw_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send_to(this->get_implementation(),
         buffers, destination, 0, ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send_to(this->get_implementation(),
+        buffers, destination, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous send.
@@ -546,7 +583,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   ASIO_INITFN_RESULT_TYPE(WriteHandler,
@@ -559,9 +596,20 @@ class basic_raw_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send_to(
         this->get_implementation(), buffers, destination, flags,
         ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send_to(
+        this->get_implementation(), buffers, destination, flags,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Receive some data on a connected socket.
@@ -673,7 +721,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
@@ -699,8 +747,18 @@ class basic_raw_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous receive on a connected socket.
@@ -725,7 +783,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
@@ -742,8 +800,18 @@ class basic_raw_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(this->get_implementation(),
         buffers, flags, ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, flags, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Receive raw data with the endpoint of the sender.
@@ -860,7 +928,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
@@ -882,9 +950,20 @@ class basic_raw_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive_from(
         this->get_implementation(), buffers, sender_endpoint, 0,
         ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, 0,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous receive.
@@ -914,7 +993,7 @@ class basic_raw_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename MutableBufferSequence, typename ReadHandler>
   ASIO_INITFN_RESULT_TYPE(ReadHandler,
@@ -927,9 +1006,20 @@ class basic_raw_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive_from(
         this->get_implementation(), buffers, sender_endpoint, flags,
         ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, flags,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 };
 
diff --git a/extern/include/asio/basic_seq_packet_socket.hpp b/extern/include/asio/basic_seq_packet_socket.hpp
index a217bbfe..3655d881 100644
--- a/extern/include/asio/basic_seq_packet_socket.hpp
+++ b/extern/include/asio/basic_seq_packet_socket.hpp
@@ -2,7 +2,7 @@
 // basic_seq_packet_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,7 +21,10 @@
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
-#include "asio/seq_packet_socket_service.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/seq_packet_socket_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 #include "asio/detail/push_options.hpp"
 
@@ -36,19 +39,19 @@ namespace asio {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
-template <typename Protocol,
-    typename SeqPacketSocketService = seq_packet_socket_service<Protocol> >
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= seq_packet_socket_service<Protocol>)>
 class basic_seq_packet_socket
-  : public basic_socket<Protocol, SeqPacketSocketService>
+  : public basic_socket<Protocol ASIO_SVC_TARG>
 {
 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;
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_socket<
+    Protocol ASIO_SVC_TARG>::native_handle_type native_handle_type;
+#endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -62,12 +65,12 @@ class basic_seq_packet_socket
    * 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
+   * @param io_context The io_context object that the sequenced packet socket
    * will use to dispatch handlers for any asynchronous operations performed on
    * the socket.
    */
-  explicit basic_seq_packet_socket(asio::io_service& io_service)
-    : basic_socket<Protocol, SeqPacketSocketService>(io_service)
+  explicit basic_seq_packet_socket(asio::io_context& io_context)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context)
   {
   }
 
@@ -77,7 +80,7 @@ class basic_seq_packet_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
+   * @param io_context The io_context object that the sequenced packet socket
    * will use to dispatch handlers for any asynchronous operations performed on
    * the socket.
    *
@@ -85,9 +88,9 @@ class basic_seq_packet_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_seq_packet_socket(asio::io_service& io_service,
+  basic_seq_packet_socket(asio::io_context& io_context,
       const protocol_type& protocol)
-    : basic_socket<Protocol, SeqPacketSocketService>(io_service, protocol)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, protocol)
   {
   }
 
@@ -98,7 +101,7 @@ class basic_seq_packet_socket
    * 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
+   * @param io_context The io_context object that the sequenced packet socket
    * will use to dispatch handlers for any asynchronous operations performed on
    * the socket.
    *
@@ -107,9 +110,9 @@ class basic_seq_packet_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_seq_packet_socket(asio::io_service& io_service,
+  basic_seq_packet_socket(asio::io_context& io_context,
       const endpoint_type& endpoint)
-    : basic_socket<Protocol, SeqPacketSocketService>(io_service, endpoint)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, endpoint)
   {
   }
 
@@ -118,7 +121,7 @@ class basic_seq_packet_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
+   * @param io_context The io_context object that the sequenced packet socket
    * will use to dispatch handlers for any asynchronous operations performed on
    * the socket.
    *
@@ -128,10 +131,10 @@ class basic_seq_packet_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_seq_packet_socket(asio::io_service& io_service,
+  basic_seq_packet_socket(asio::io_context& io_context,
       const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, SeqPacketSocketService>(
-        io_service, protocol, native_socket)
+    : basic_socket<Protocol ASIO_SVC_TARG>(
+        io_context, protocol, native_socket)
   {
   }
 
@@ -145,11 +148,10 @@ class basic_seq_packet_socket
    * 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.
+   * constructed using the @c basic_seq_packet_socket(io_context&) constructor.
    */
   basic_seq_packet_socket(basic_seq_packet_socket&& other)
-    : basic_socket<Protocol, SeqPacketSocketService>(
-        ASIO_MOVE_CAST(basic_seq_packet_socket)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -162,12 +164,11 @@ class basic_seq_packet_socket
    * 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.
+   * constructed using the @c basic_seq_packet_socket(io_context&) constructor.
    */
   basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
   {
-    basic_socket<Protocol, SeqPacketSocketService>::operator=(
-        ASIO_MOVE_CAST(basic_seq_packet_socket)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 
@@ -181,15 +182,13 @@ class basic_seq_packet_socket
    * 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.
+   * constructed using the @c basic_seq_packet_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename SeqPacketSocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   basic_seq_packet_socket(
-      basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other,
+      basic_seq_packet_socket<Protocol1 ASIO_SVC_TARG1>&& other,
       typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
-    : basic_socket<Protocol, SeqPacketSocketService>(
-        ASIO_MOVE_CAST2(basic_seq_packet_socket<
-          Protocol1, SeqPacketSocketService1>)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -203,20 +202,27 @@ class basic_seq_packet_socket
    * 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.
+   * constructed using the @c basic_seq_packet_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename SeqPacketSocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   typename enable_if<is_convertible<Protocol1, Protocol>::value,
       basic_seq_packet_socket>::type& operator=(
-        basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other)
+        basic_seq_packet_socket<Protocol1 ASIO_SVC_TARG1>&& other)
   {
-    basic_socket<Protocol, SeqPacketSocketService>::operator=(
-        ASIO_MOVE_CAST2(basic_seq_packet_socket<
-          Protocol1, SeqPacketSocketService1>)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
+  /// Destroys the socket.
+  /**
+   * This function destroys the socket, cancelling any outstanding asynchronous
+   * operations associated with the socket as if by calling @c cancel.
+   */
+  ~basic_seq_packet_socket()
+  {
+  }
+
   /// Send some data on the socket.
   /**
    * This function is used to send data on the sequenced packet socket. The
@@ -299,7 +305,7 @@ class basic_seq_packet_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
@@ -321,8 +327,18 @@ class basic_seq_packet_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(this->get_implementation(),
         buffers, flags, ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, flags, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Receive some data on the socket.
@@ -359,8 +375,13 @@ class basic_seq_packet_socket
       socket_base::message_flags& out_flags)
   {
     asio::error_code ec;
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     std::size_t s = this->get_service().receive(
         this->get_implementation(), buffers, 0, out_flags, ec);
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    std::size_t s = this->get_service().receive_with_flags(
+        this->get_implementation(), buffers, 0, out_flags, ec);
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
     asio::detail::throw_error(ec, "receive");
     return s;
   }
@@ -406,8 +427,13 @@ class basic_seq_packet_socket
       socket_base::message_flags& out_flags)
   {
     asio::error_code ec;
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     std::size_t s = this->get_service().receive(
         this->get_implementation(), buffers, in_flags, out_flags, ec);
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    std::size_t s = this->get_service().receive_with_flags(
+        this->get_implementation(), buffers, in_flags, out_flags, ec);
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
     asio::detail::throw_error(ec, "receive");
     return s;
   }
@@ -440,8 +466,13 @@ class basic_seq_packet_socket
       socket_base::message_flags in_flags,
       socket_base::message_flags& out_flags, asio::error_code& ec)
   {
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().receive(this->get_implementation(),
         buffers, in_flags, out_flags, ec);
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().receive_with_flags(this->get_implementation(),
+        buffers, in_flags, out_flags, ec);
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous receive.
@@ -470,7 +501,7 @@ class basic_seq_packet_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
@@ -493,9 +524,20 @@ class basic_seq_packet_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(
         this->get_implementation(), buffers, 0, out_flags,
         ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive_with_flags(
+        this->get_implementation(), buffers, 0, out_flags,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous receive.
@@ -526,7 +568,7 @@ class basic_seq_packet_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
@@ -552,9 +594,20 @@ class basic_seq_packet_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(
         this->get_implementation(), buffers, in_flags, out_flags,
         ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive_with_flags(
+        this->get_implementation(), buffers, in_flags, out_flags,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 };
 
diff --git a/extern/include/asio/basic_serial_port.hpp b/extern/include/asio/basic_serial_port.hpp
index ab170e52..32262f84 100644
--- a/extern/include/asio/basic_serial_port.hpp
+++ b/extern/include/asio/basic_serial_port.hpp
@@ -2,7 +2,7 @@
 // basic_serial_port.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -18,6 +18,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -48,10 +50,6 @@ 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_handle_type native_handle_type;
 
@@ -62,11 +60,11 @@ class basic_serial_port
   /**
    * This constructor creates a serial port without opening it.
    *
-   * @param io_service The io_service object that the serial port will use to
+   * @param io_context The io_context object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    */
-  explicit basic_serial_port(asio::io_service& io_service)
-    : basic_io_object<SerialPortService>(io_service)
+  explicit basic_serial_port(asio::io_context& io_context)
+    : basic_io_object<SerialPortService>(io_context)
   {
   }
 
@@ -75,15 +73,15 @@ class basic_serial_port
    * This constructor creates and opens a serial port for the specified device
    * name.
    *
-   * @param io_service The io_service object that the serial port will use to
+   * @param io_context The io_context object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    *
    * @param device The platform-specific device name for this serial
    * port.
    */
-  explicit basic_serial_port(asio::io_service& io_service,
+  explicit basic_serial_port(asio::io_context& io_context,
       const char* device)
-    : basic_io_object<SerialPortService>(io_service)
+    : basic_io_object<SerialPortService>(io_context)
   {
     asio::error_code ec;
     this->get_service().open(this->get_implementation(), device, ec);
@@ -95,15 +93,15 @@ class basic_serial_port
    * This constructor creates and opens a serial port for the specified device
    * name.
    *
-   * @param io_service The io_service object that the serial port will use to
+   * @param io_context The io_context object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    *
    * @param device The platform-specific device name for this serial
    * port.
    */
-  explicit basic_serial_port(asio::io_service& io_service,
+  explicit basic_serial_port(asio::io_context& io_context,
       const std::string& device)
-    : basic_io_object<SerialPortService>(io_service)
+    : basic_io_object<SerialPortService>(io_context)
   {
     asio::error_code ec;
     this->get_service().open(this->get_implementation(), device, ec);
@@ -115,16 +113,16 @@ class basic_serial_port
    * This constructor creates a serial port object to hold an existing native
    * serial port.
    *
-   * @param io_service The io_service object that the serial port will use to
+   * @param io_context The io_context object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    *
    * @param native_serial_port A native serial port.
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_serial_port(asio::io_service& io_service,
+  basic_serial_port(asio::io_context& io_context,
       const native_handle_type& native_serial_port)
-    : basic_io_object<SerialPortService>(io_service)
+    : basic_io_object<SerialPortService>(io_context)
   {
     asio::error_code ec;
     this->get_service().assign(this->get_implementation(),
@@ -141,7 +139,7 @@ class basic_serial_port
    * 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.
+   * constructed using the @c basic_serial_port(io_context&) constructor.
    */
   basic_serial_port(basic_serial_port&& other)
     : basic_io_object<SerialPortService>(
@@ -157,7 +155,7 @@ class basic_serial_port
    * 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.
+   * constructed using the @c basic_serial_port(io_context&) constructor.
    */
   basic_serial_port& operator=(basic_serial_port&& other)
   {
@@ -219,10 +217,11 @@ class basic_serial_port
    *
    * @param ec Set the indicate what error occurred, if any.
    */
-  asio::error_code open(const std::string& device,
+  ASIO_SYNC_OP_VOID open(const std::string& device,
       asio::error_code& ec)
   {
-    return this->get_service().open(this->get_implementation(), device, ec);
+    this->get_service().open(this->get_implementation(), device, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native serial port to the serial port.
@@ -249,11 +248,12 @@ class basic_serial_port
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code assign(const native_handle_type& native_serial_port,
+  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_serial_port,
       asio::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(),
+    this->get_service().assign(this->get_implementation(),
         native_serial_port, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the serial port is open.
@@ -285,21 +285,10 @@ class basic_serial_port
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code close(asio::error_code& ec)
-  {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (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
-   * functionality that is not otherwise provided.
-   */
-  native_type native()
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return this->get_service().native_handle(this->get_implementation());
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native serial port representation.
@@ -336,9 +325,10 @@ class basic_serial_port
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code cancel(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Send a break sequence to the serial port.
@@ -362,9 +352,10 @@ class basic_serial_port
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code send_break(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID send_break(asio::error_code& ec)
   {
-    return this->get_service().send_break(this->get_implementation(), ec);
+    this->get_service().send_break(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Set an option on the serial port.
@@ -406,11 +397,11 @@ class basic_serial_port
    * asio::serial_port_base::character_size
    */
   template <typename SettableSerialPortOption>
-  asio::error_code set_option(const SettableSerialPortOption& option,
+  ASIO_SYNC_OP_VOID set_option(const SettableSerialPortOption& option,
       asio::error_code& ec)
   {
-    return this->get_service().set_option(
-        this->get_implementation(), option, ec);
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get an option from the serial port.
@@ -444,7 +435,7 @@ class basic_serial_port
    *
    * @param option The option value to be obtained from the serial port.
    *
-   * @param ec Set to indicate what error occured, if any.
+   * @param ec Set to indicate what error occurred, if any.
    *
    * @sa GettableSerialPortOption @n
    * asio::serial_port_base::baud_rate @n
@@ -454,11 +445,11 @@ class basic_serial_port
    * asio::serial_port_base::character_size
    */
   template <typename GettableSerialPortOption>
-  asio::error_code get_option(GettableSerialPortOption& option,
+  ASIO_SYNC_OP_VOID get_option(GettableSerialPortOption& option,
       asio::error_code& ec)
   {
-    return this->get_service().get_option(
-        this->get_implementation(), option, ec);
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Write some data to the serial port.
@@ -542,7 +533,7 @@ class basic_serial_port
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
@@ -654,7 +645,7 @@ class basic_serial_port
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
@@ -692,4 +683,6 @@ class basic_serial_port
 #endif // defined(ASIO_HAS_SERIAL_PORT)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_BASIC_SERIAL_PORT_HPP
diff --git a/extern/include/asio/basic_signal_set.hpp b/extern/include/asio/basic_signal_set.hpp
index bc54980a..cf34643f 100644
--- a/extern/include/asio/basic_signal_set.hpp
+++ b/extern/include/asio/basic_signal_set.hpp
@@ -2,7 +2,7 @@
 // basic_signal_set.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/basic_io_object.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/throw_error.hpp"
@@ -54,7 +56,7 @@ namespace asio {
  * ...
  *
  * // Construct a signal set registered for process termination.
- * asio::signal_set signals(io_service, SIGINT, SIGTERM);
+ * asio::signal_set signals(io_context, SIGINT, SIGTERM);
  *
  * // Start an asynchronous wait for one of the signals to occur.
  * signals.async_wait(handler);
@@ -98,11 +100,11 @@ class basic_signal_set
   /**
    * 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
+   * @param io_context The io_context object that the signal set will use to
    * dispatch handlers for any asynchronous operations performed on the set.
    */
-  explicit basic_signal_set(asio::io_service& io_service)
-    : basic_io_object<SignalSetService>(io_service)
+  explicit basic_signal_set(asio::io_context& io_context)
+    : basic_io_object<SignalSetService>(io_context)
   {
   }
 
@@ -110,20 +112,20 @@ class basic_signal_set
   /**
    * 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
+   * @param io_context The io_context 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 asio::signal_set signals(io_service);
+   * @code asio::signal_set signals(io_context);
    * signals.add(signal_number_1); @endcode
    */
-  basic_signal_set(asio::io_service& io_service, int signal_number_1)
-    : basic_io_object<SignalSetService>(io_service)
+  basic_signal_set(asio::io_context& io_context, int signal_number_1)
+    : basic_io_object<SignalSetService>(io_context)
   {
     asio::error_code ec;
-    this->service.add(this->implementation, signal_number_1, ec);
+    this->get_service().add(this->get_implementation(), signal_number_1, ec);
     asio::detail::throw_error(ec, "add");
   }
 
@@ -131,7 +133,7 @@ class basic_signal_set
   /**
    * 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
+   * @param io_context The io_context 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.
@@ -139,18 +141,18 @@ class basic_signal_set
    * @param signal_number_2 The second signal number to be added.
    *
    * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(io_service);
+   * @code asio::signal_set signals(io_context);
    * signals.add(signal_number_1);
    * signals.add(signal_number_2); @endcode
    */
-  basic_signal_set(asio::io_service& io_service, int signal_number_1,
+  basic_signal_set(asio::io_context& io_context, int signal_number_1,
       int signal_number_2)
-    : basic_io_object<SignalSetService>(io_service)
+    : basic_io_object<SignalSetService>(io_context)
   {
     asio::error_code ec;
-    this->service.add(this->implementation, signal_number_1, ec);
+    this->get_service().add(this->get_implementation(), signal_number_1, ec);
     asio::detail::throw_error(ec, "add");
-    this->service.add(this->implementation, signal_number_2, ec);
+    this->get_service().add(this->get_implementation(), signal_number_2, ec);
     asio::detail::throw_error(ec, "add");
   }
 
@@ -158,7 +160,7 @@ class basic_signal_set
   /**
    * 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
+   * @param io_context The io_context 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.
@@ -168,21 +170,21 @@ class basic_signal_set
    * @param signal_number_3 The third signal number to be added.
    *
    * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(io_service);
+   * @code asio::signal_set signals(io_context);
    * signals.add(signal_number_1);
    * signals.add(signal_number_2);
    * signals.add(signal_number_3); @endcode
    */
-  basic_signal_set(asio::io_service& io_service, int signal_number_1,
+  basic_signal_set(asio::io_context& io_context, int signal_number_1,
       int signal_number_2, int signal_number_3)
-    : basic_io_object<SignalSetService>(io_service)
+    : basic_io_object<SignalSetService>(io_context)
   {
     asio::error_code ec;
-    this->service.add(this->implementation, signal_number_1, ec);
+    this->get_service().add(this->get_implementation(), signal_number_1, ec);
     asio::detail::throw_error(ec, "add");
-    this->service.add(this->implementation, signal_number_2, ec);
+    this->get_service().add(this->get_implementation(), signal_number_2, ec);
     asio::detail::throw_error(ec, "add");
-    this->service.add(this->implementation, signal_number_3, ec);
+    this->get_service().add(this->get_implementation(), signal_number_3, ec);
     asio::detail::throw_error(ec, "add");
   }
 
@@ -198,7 +200,7 @@ class basic_signal_set
   void add(int signal_number)
   {
     asio::error_code ec;
-    this->service.add(this->implementation, signal_number, ec);
+    this->get_service().add(this->get_implementation(), signal_number, ec);
     asio::detail::throw_error(ec, "add");
   }
 
@@ -211,10 +213,10 @@ class basic_signal_set
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code add(int signal_number,
-      asio::error_code& ec)
+  ASIO_SYNC_OP_VOID add(int signal_number, asio::error_code& ec)
   {
-    return this->service.add(this->implementation, signal_number, ec);
+    this->get_service().add(this->get_implementation(), signal_number, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Remove a signal from a signal_set.
@@ -232,7 +234,7 @@ class basic_signal_set
   void remove(int signal_number)
   {
     asio::error_code ec;
-    this->service.remove(this->implementation, signal_number, ec);
+    this->get_service().remove(this->get_implementation(), signal_number, ec);
     asio::detail::throw_error(ec, "remove");
   }
 
@@ -248,10 +250,11 @@ class basic_signal_set
    * @note Removes any notifications that have been queued for the specified
    * signal number.
    */
-  asio::error_code remove(int signal_number,
+  ASIO_SYNC_OP_VOID remove(int signal_number,
       asio::error_code& ec)
   {
-    return this->service.remove(this->implementation, signal_number, ec);
+    this->get_service().remove(this->get_implementation(), signal_number, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Remove all signals from a signal_set.
@@ -266,7 +269,7 @@ class basic_signal_set
   void clear()
   {
     asio::error_code ec;
-    this->service.clear(this->implementation, ec);
+    this->get_service().clear(this->get_implementation(), ec);
     asio::detail::throw_error(ec, "clear");
   }
 
@@ -279,9 +282,10 @@ class basic_signal_set
    *
    * @note Removes all queued notifications.
    */
-  asio::error_code clear(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID clear(asio::error_code& ec)
   {
-    return this->service.clear(this->implementation, ec);
+    this->get_service().clear(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Cancel all operations associated with the signal set.
@@ -308,7 +312,7 @@ class basic_signal_set
   void cancel()
   {
     asio::error_code ec;
-    this->service.cancel(this->implementation, ec);
+    this->get_service().cancel(this->get_implementation(), ec);
     asio::detail::throw_error(ec, "cancel");
   }
 
@@ -333,9 +337,10 @@ class basic_signal_set
    * These handlers can no longer be cancelled, and therefore are passed an
    * error code that indicates the successful completion of the wait operation.
    */
-  asio::error_code cancel(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous operation to wait for a signal to be delivered.
@@ -361,7 +366,7 @@ class basic_signal_set
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename SignalHandler>
   ASIO_INITFN_RESULT_TYPE(SignalHandler,
@@ -372,7 +377,7 @@ class basic_signal_set
     // not meet the documented type requirements for a SignalHandler.
     ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
 
-    return this->service.async_wait(this->implementation,
+    return this->get_service().async_wait(this->get_implementation(),
         ASIO_MOVE_CAST(SignalHandler)(handler));
   }
 };
@@ -381,4 +386,6 @@ class basic_signal_set
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_BASIC_SIGNAL_SET_HPP
diff --git a/extern/include/asio/basic_socket.hpp b/extern/include/asio/basic_socket.hpp
index d080bdbe..3dfacb42 100644
--- a/extern/include/asio/basic_socket.hpp
+++ b/extern/include/asio/basic_socket.hpp
@@ -2,7 +2,7 @@
 // basic_socket.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,8 +22,26 @@
 #include "asio/detail/throw_error.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
+#include "asio/post.hpp"
 #include "asio/socket_base.hpp"
 
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# if defined(ASIO_WINDOWS_RUNTIME)
+#  include "asio/detail/winrt_ssocket_service.hpp"
+#  define ASIO_SVC_T detail::winrt_ssocket_service<Protocol>
+# elif defined(ASIO_HAS_IOCP)
+#  include "asio/detail/win_iocp_socket_service.hpp"
+#  define ASIO_SVC_T detail::win_iocp_socket_service<Protocol>
+# else
+#  include "asio/detail/reactive_socket_service.hpp"
+#  define ASIO_SVC_T detail::reactive_socket_service<Protocol>
+# endif
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -37,18 +55,21 @@ namespace asio {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
-template <typename Protocol, typename SocketService>
+template <typename Protocol ASIO_SVC_TPARAM>
 class basic_socket
-  : public basic_io_object<SocketService>,
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>,
     public socket_base
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// socket.
-  typedef typename SocketService::native_handle_type native_type;
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
 
   /// The native representation of a socket.
-  typedef typename SocketService::native_handle_type native_handle_type;
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename ASIO_SVC_T::native_handle_type native_handle_type;
+#endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -56,18 +77,20 @@ class basic_socket
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
+#if !defined(ASIO_NO_EXTENSIONS)
   /// A basic_socket is always the lowest layer.
-  typedef basic_socket<Protocol, SocketService> lowest_layer_type;
+  typedef basic_socket<Protocol ASIO_SVC_TARG> lowest_layer_type;
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
   /// Construct a basic_socket without opening it.
   /**
    * This constructor creates a socket without opening it.
    *
-   * @param io_service The io_service object that the socket will use to
+   * @param io_context The io_context object that the socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    */
-  explicit basic_socket(asio::io_service& io_service)
-    : basic_io_object<SocketService>(io_service)
+  explicit basic_socket(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
   }
 
@@ -75,16 +98,16 @@ class basic_socket
   /**
    * This constructor creates and opens a socket.
    *
-   * @param io_service The io_service object that the socket will use to
+   * @param io_context The io_context object that the 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 asio::system_error Thrown on failure.
    */
-  basic_socket(asio::io_service& io_service,
+  basic_socket(asio::io_context& io_context,
       const protocol_type& protocol)
-    : basic_io_object<SocketService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
     this->get_service().open(this->get_implementation(), protocol, ec);
@@ -98,7 +121,7 @@ class basic_socket
    * 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 socket will use to
+   * @param io_context The io_context object that the 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 socket will
@@ -106,9 +129,9 @@ class basic_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_socket(asio::io_service& io_service,
+  basic_socket(asio::io_context& io_context,
       const endpoint_type& endpoint)
-    : basic_io_object<SocketService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
     const protocol_type protocol = endpoint.protocol();
@@ -122,7 +145,7 @@ class basic_socket
   /**
    * This constructor creates a socket object to hold an existing native socket.
    *
-   * @param io_service The io_service object that the socket will use to
+   * @param io_context The io_context object that the socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
@@ -131,9 +154,9 @@ class basic_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_socket(asio::io_service& io_service,
+  basic_socket(asio::io_context& io_context,
       const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_io_object<SocketService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
     this->get_service().assign(this->get_implementation(),
@@ -150,11 +173,10 @@ class basic_socket
    * 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.
+   * constructed using the @c basic_socket(io_context&) constructor.
    */
   basic_socket(basic_socket&& other)
-    : basic_io_object<SocketService>(
-        ASIO_MOVE_CAST(basic_socket)(other))
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
   {
   }
 
@@ -166,17 +188,16 @@ class basic_socket
    * 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.
+   * constructed using the @c basic_socket(io_context&) constructor.
    */
   basic_socket& operator=(basic_socket&& other)
   {
-    basic_io_object<SocketService>::operator=(
-        ASIO_MOVE_CAST(basic_socket)(other));
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
     return *this;
   }
 
   // All sockets have access to each other's implementations.
-  template <typename Protocol1, typename SocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   friend class basic_socket;
 
   /// Move-construct a basic_socket from a socket of another protocol type.
@@ -187,15 +208,14 @@ class basic_socket
    * 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.
+   * constructed using the @c basic_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename SocketService1>
-  basic_socket(basic_socket<Protocol1, SocketService1>&& other,
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
+  basic_socket(basic_socket<Protocol1 ASIO_SVC_TARG1>&& other,
       typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
-    : basic_io_object<SocketService>(other.get_io_service())
+    : basic_io_object<ASIO_SVC_T>(
+        other.get_service(), other.get_implementation())
   {
-    this->get_service().template converting_move_construct<Protocol1>(
-        this->get_implementation(), other.get_implementation());
   }
 
   /// Move-assign a basic_socket from a socket of another protocol type.
@@ -206,21 +226,60 @@ class basic_socket
    * 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.
+   * constructed using the @c basic_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename SocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   typename enable_if<is_convertible<Protocol1, Protocol>::value,
       basic_socket>::type& operator=(
-        basic_socket<Protocol1, SocketService1>&& other)
+        basic_socket<Protocol1 ASIO_SVC_TARG1>&& other)
   {
-    basic_socket tmp(ASIO_MOVE_CAST2(basic_socket<
-            Protocol1, SocketService1>)(other));
-    basic_io_object<SocketService>::operator=(
-        ASIO_MOVE_CAST(basic_socket)(tmp));
+    basic_socket tmp(std::move(other));
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(tmp));
     return *this;
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+  // These functions are provided by basic_io_object<>.
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+#if !defined(ASIO_NO_EXTENSIONS)
   /// Get a reference to the lowest layer.
   /**
    * This function returns a reference to the lowest layer in a stack of
@@ -248,6 +307,7 @@ class basic_socket
   {
     return *this;
   }
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
   /// Open the socket using the specified protocol.
   /**
@@ -259,7 +319,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * socket.open(asio::ip::tcp::v4());
    * @endcode
    */
@@ -280,7 +340,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * asio::error_code ec;
    * socket.open(asio::ip::tcp::v4(), ec);
    * if (ec)
@@ -289,10 +349,11 @@ class basic_socket
    * }
    * @endcode
    */
-  asio::error_code open(const protocol_type& protocol,
+  ASIO_SYNC_OP_VOID open(const protocol_type& protocol,
       asio::error_code& ec)
   {
-    return this->get_service().open(this->get_implementation(), protocol, ec);
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native socket to the socket.
@@ -324,11 +385,12 @@ class basic_socket
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code assign(const protocol_type& protocol,
+  ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,
       const native_handle_type& native_socket, asio::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(),
+    this->get_service().assign(this->get_implementation(),
         protocol, native_socket, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is open.
@@ -367,7 +429,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::error_code ec;
    * socket.close(ec);
@@ -380,20 +442,62 @@ class basic_socket
    * @note For portable behaviour with respect to graceful closure of a
    * connected socket, call shutdown() before closing the socket.
    */
-  asio::error_code close(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket representation.
+  /// Release ownership of the underlying native socket.
   /**
-   * 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.
+   * This function causes all outstanding asynchronous connect, send and receive
+   * operations to finish immediately, and the handlers for cancelled operations
+   * will be passed the asio::error::operation_aborted error. Ownership
+   * of the native socket is then transferred to the caller.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release()
+  {
+    asio::error_code ec;
+    native_handle_type s = this->get_service().release(
+        this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "release");
+    return s;
+  }
+
+  /// Release ownership of the underlying native socket.
+  /**
+   * This function causes all outstanding asynchronous connect, send and receive
+   * operations to finish immediately, and the handlers for cancelled operations
+   * will be passed the asio::error::operation_aborted error. Ownership
+   * of the native socket is then transferred to the caller.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with asio::error::operation_not_supported on
+   * these platforms.
    */
-  native_type native()
+#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release(asio::error_code& ec)
   {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->get_service().release(this->get_implementation(), ec);
   }
 
   /// Get the native socket representation.
@@ -496,9 +600,10 @@ class basic_socket
         "operation_not_supported when used on Windows XP, Windows Server 2003, "
         "or earlier. Consult documentation for details."))
 #endif
-  asio::error_code cancel(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
@@ -580,7 +685,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * socket.open(asio::ip::tcp::v4());
    * socket.bind(asio::ip::tcp::endpoint(
    *       asio::ip::tcp::v4(), 12345));
@@ -605,7 +710,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * socket.open(asio::ip::tcp::v4());
    * asio::error_code ec;
    * socket.bind(asio::ip::tcp::endpoint(
@@ -616,10 +721,11 @@ class basic_socket
    * }
    * @endcode
    */
-  asio::error_code bind(const endpoint_type& endpoint,
+  ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,
       asio::error_code& ec)
   {
-    return this->get_service().bind(this->get_implementation(), endpoint, ec);
+    this->get_service().bind(this->get_implementation(), endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Connect the socket to the specified endpoint.
@@ -639,7 +745,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * asio::ip::tcp::endpoint endpoint(
    *     asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.connect(endpoint);
@@ -675,7 +781,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * asio::ip::tcp::endpoint endpoint(
    *     asio::ip::address::from_string("1.2.3.4"), 12345);
    * asio::error_code ec;
@@ -686,20 +792,21 @@ class basic_socket
    * }
    * @endcode
    */
-  asio::error_code connect(const endpoint_type& peer_endpoint,
+  ASIO_SYNC_OP_VOID connect(const endpoint_type& peer_endpoint,
       asio::error_code& ec)
   {
     if (!is_open())
     {
-      if (this->get_service().open(this->get_implementation(),
-            peer_endpoint.protocol(), ec))
+      this->get_service().open(this->get_implementation(),
+            peer_endpoint.protocol(), ec);
+      if (ec)
       {
-        return ec;
+        ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
 
-    return this->get_service().connect(
-        this->get_implementation(), peer_endpoint, ec);
+    this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous connect.
@@ -723,7 +830,7 @@ class basic_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * @code
@@ -737,7 +844,7 @@ class basic_socket
    *
    * ...
    *
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * asio::ip::tcp::endpoint endpoint(
    *     asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.async_connect(endpoint, connect_handler);
@@ -757,24 +864,34 @@ class basic_socket
     {
       asio::error_code ec;
       const protocol_type protocol = peer_endpoint.protocol();
-      if (this->get_service().open(this->get_implementation(), protocol, ec))
+      this->get_service().open(this->get_implementation(), protocol, ec);
+      if (ec)
       {
-        detail::async_result_init<
-          ConnectHandler, void (asio::error_code)> init(
-            ASIO_MOVE_CAST(ConnectHandler)(handler));
+        async_completion<ConnectHandler,
+          void (asio::error_code)> init(handler);
 
-        this->get_io_service().post(
+        asio::post(this->get_executor(),
             asio::detail::bind_handler(
               ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(
                 ConnectHandler, void (asio::error_code)))(
-                  init.handler), ec));
+                  init.completion_handler), ec));
 
         return init.result.get();
       }
     }
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_connect(this->get_implementation(),
         peer_endpoint, ASIO_MOVE_CAST(ConnectHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ConnectHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_connect(
+        this->get_implementation(), peer_endpoint, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Set an option on the socket.
@@ -805,7 +922,7 @@ class basic_socket
    * @par Example
    * Setting the IPPROTO_TCP/TCP_NODELAY option:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::no_delay option(true);
    * socket.set_option(option);
@@ -847,7 +964,7 @@ class basic_socket
    * @par Example
    * Setting the IPPROTO_TCP/TCP_NODELAY option:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::no_delay option(true);
    * asio::error_code ec;
@@ -859,11 +976,11 @@ class basic_socket
    * @endcode
    */
   template <typename SettableSocketOption>
-  asio::error_code set_option(const SettableSocketOption& option,
+  ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,
       asio::error_code& ec)
   {
-    return this->get_service().set_option(
-        this->get_implementation(), option, ec);
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get an option from the socket.
@@ -894,7 +1011,7 @@ class basic_socket
    * @par Example
    * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::socket::keep_alive option;
    * socket.get_option(option);
@@ -937,7 +1054,7 @@ class basic_socket
    * @par Example
    * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::socket::keep_alive option;
    * asio::error_code ec;
@@ -950,11 +1067,11 @@ class basic_socket
    * @endcode
    */
   template <typename GettableSocketOption>
-  asio::error_code get_option(GettableSocketOption& option,
+  ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,
       asio::error_code& ec) const
   {
-    return this->get_service().get_option(
-        this->get_implementation(), option, ec);
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the socket.
@@ -972,7 +1089,7 @@ class basic_socket
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::socket::bytes_readable command;
    * socket.io_control(command);
@@ -1002,7 +1119,7 @@ class basic_socket
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::socket::bytes_readable command;
    * asio::error_code ec;
@@ -1015,11 +1132,11 @@ class basic_socket
    * @endcode
    */
   template <typename IoControlCommand>
-  asio::error_code io_control(IoControlCommand& command,
+  ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
       asio::error_code& ec)
   {
-    return this->get_service().io_control(
-        this->get_implementation(), command, ec);
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the socket.
@@ -1071,11 +1188,11 @@ class basic_socket
    * operations. Asynchronous operations will never fail with the error
    * asio::error::would_block.
    */
-  asio::error_code non_blocking(
+  ASIO_SYNC_OP_VOID non_blocking(
       bool mode, asio::error_code& ec)
   {
-    return this->get_service().non_blocking(
-        this->get_implementation(), mode, ec);
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native socket implementation.
@@ -1135,7 +1252,7 @@ class basic_socket
    *             || ec == asio::error::try_again)
    *         {
    *           // We have to wait for the socket to become ready again.
-   *           sock_.async_write_some(asio::null_buffers(), *this);
+   *           sock_.async_wait(tcp::socket::wait_write, *this);
    *           return;
    *         }
    *
@@ -1159,7 +1276,7 @@ class basic_socket
    * void async_sendfile(tcp::socket& sock, int fd, Handler h)
    * {
    *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_write_some(asio::null_buffers(), op);
+   *   sock.async_wait(tcp::socket::wait_write, op);
    * } @endcode
    */
   bool native_non_blocking() const
@@ -1225,7 +1342,7 @@ class basic_socket
    *             || ec == asio::error::try_again)
    *         {
    *           // We have to wait for the socket to become ready again.
-   *           sock_.async_write_some(asio::null_buffers(), *this);
+   *           sock_.async_wait(tcp::socket::wait_write, *this);
    *           return;
    *         }
    *
@@ -1249,7 +1366,7 @@ class basic_socket
    * void async_sendfile(tcp::socket& sock, int fd, Handler h)
    * {
    *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_write_some(asio::null_buffers(), op);
+   *   sock.async_wait(tcp::socket::wait_write, op);
    * } @endcode
    */
   void native_non_blocking(bool mode)
@@ -1318,7 +1435,7 @@ class basic_socket
    *             || ec == asio::error::try_again)
    *         {
    *           // We have to wait for the socket to become ready again.
-   *           sock_.async_write_some(asio::null_buffers(), *this);
+   *           sock_.async_wait(tcp::socket::wait_write, *this);
    *           return;
    *         }
    *
@@ -1342,14 +1459,15 @@ class basic_socket
    * void async_sendfile(tcp::socket& sock, int fd, Handler h)
    * {
    *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_write_some(asio::null_buffers(), op);
+   *   sock.async_wait(tcp::socket::wait_write, op);
    * } @endcode
    */
-  asio::error_code native_non_blocking(
+  ASIO_SYNC_OP_VOID native_non_blocking(
       bool mode, asio::error_code& ec)
   {
-    return this->get_service().native_non_blocking(
+    this->get_service().native_non_blocking(
         this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the local endpoint of the socket.
@@ -1362,7 +1480,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
    * @endcode
@@ -1387,7 +1505,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::error_code ec;
    * asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
@@ -1412,7 +1530,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
    * @endcode
@@ -1437,7 +1555,7 @@ class basic_socket
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::error_code ec;
    * asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
@@ -1464,7 +1582,7 @@ class basic_socket
    * @par Example
    * Shutting down the send side of the socket:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * socket.shutdown(asio::ip::tcp::socket::shutdown_send);
    * @endcode
@@ -1488,7 +1606,7 @@ class basic_socket
    * @par Example
    * Shutting down the send side of the socket:
    * @code
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * ...
    * asio::error_code ec;
    * socket.shutdown(asio::ip::tcp::socket::shutdown_send, ec);
@@ -1498,21 +1616,142 @@ class basic_socket
    * }
    * @endcode
    */
-  asio::error_code shutdown(shutdown_type what,
+  ASIO_SYNC_OP_VOID shutdown(shutdown_type what,
       asio::error_code& ec)
   {
-    return this->get_service().shutdown(this->get_implementation(), what, ec);
+    this->get_service().shutdown(this->get_implementation(), what, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the socket to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for a socket to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired socket state.
+   *
+   * @par Example
+   * Waiting for a socket to become readable.
+   * @code
+   * asio::ip::tcp::socket socket(io_context);
+   * ...
+   * socket.wait(asio::ip::tcp::socket::wait_read);
+   * @endcode
+   */
+  void wait(wait_type w)
+  {
+    asio::error_code ec;
+    this->get_service().wait(this->get_implementation(), w, ec);
+    asio::detail::throw_error(ec, "wait");
+  }
+
+  /// Wait for the socket to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for a socket to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired socket state.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * Waiting for a socket to become readable.
+   * @code
+   * asio::ip::tcp::socket socket(io_context);
+   * ...
+   * asio::error_code ec;
+   * socket.wait(asio::ip::tcp::socket::wait_read, ec);
+   * @endcode
+   */
+  ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
+  {
+    this->get_service().wait(this->get_implementation(), w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the socket to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  /**
+   * This function is used to perform an asynchronous wait for a socket to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired socket state.
+   *
+   * @param handler The handler to be called when the wait operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error // Result of operation
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void wait_handler(const asio::error_code& error)
+   * {
+   *   if (!error)
+   *   {
+   *     // Wait succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::ip::tcp::socket socket(io_context);
+   * ...
+   * socket.async_wait(asio::ip::tcp::socket::wait_read, wait_handler);
+   * @endcode
+   */
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(wait_type w, ASIO_MOVE_ARG(WaitHandler) 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.
+    ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_wait(this->get_implementation(),
+        w, ASIO_MOVE_CAST(WaitHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_wait(this->get_implementation(),
+        w, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
 protected:
   /// Protected destructor to prevent deletion through this type.
+  /**
+   * This function destroys the socket, cancelling any outstanding asynchronous
+   * operations associated with the socket as if by calling @c cancel.
+   */
   ~basic_socket()
   {
   }
+
+private:
+  // Disallow copying and assignment.
+  basic_socket(const basic_socket&) ASIO_DELETED;
+  basic_socket& operator=(const basic_socket&) ASIO_DELETED;
 };
 
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# undef ASIO_SVC_T
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_BASIC_SOCKET_HPP
diff --git a/extern/include/asio/basic_socket_acceptor.hpp b/extern/include/asio/basic_socket_acceptor.hpp
index aa55f41b..ed201bbc 100644
--- a/extern/include/asio/basic_socket_acceptor.hpp
+++ b/extern/include/asio/basic_socket_acceptor.hpp
@@ -2,7 +2,7 @@
 // basic_socket_acceptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,9 +22,27 @@
 #include "asio/detail/throw_error.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/socket_acceptor_service.hpp"
 #include "asio/socket_base.hpp"
 
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/socket_acceptor_service.hpp"
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+# if defined(ASIO_WINDOWS_RUNTIME)
+#  include "asio/detail/null_socket_service.hpp"
+#  define ASIO_SVC_T detail::null_socket_service<Protocol>
+# elif defined(ASIO_HAS_IOCP)
+#  include "asio/detail/win_iocp_socket_service.hpp"
+#  define ASIO_SVC_T detail::win_iocp_socket_service<Protocol>
+# else
+#  include "asio/detail/reactive_socket_service.hpp"
+#  define ASIO_SVC_T detail::reactive_socket_service<Protocol>
+# endif
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -41,7 +59,7 @@ namespace asio {
  * @par Example
  * Opening a socket acceptor with the SO_REUSEADDR option enabled:
  * @code
- * asio::ip::tcp::acceptor acceptor(io_service);
+ * asio::ip::tcp::acceptor acceptor(io_context);
  * asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
  * acceptor.open(endpoint.protocol());
  * acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
@@ -49,19 +67,22 @@ namespace asio {
  * acceptor.listen();
  * @endcode
  */
-template <typename Protocol,
-    typename SocketAcceptorService = socket_acceptor_service<Protocol> >
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= socket_acceptor_service<Protocol>)>
 class basic_socket_acceptor
-  : public basic_io_object<SocketAcceptorService>,
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>,
     public socket_base
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of an
-  /// acceptor.
-  typedef typename SocketAcceptorService::native_handle_type native_type;
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
 
   /// The native representation of an acceptor.
-  typedef typename SocketAcceptorService::native_handle_type native_handle_type;
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename ASIO_SVC_T::native_handle_type native_handle_type;
+#endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -75,12 +96,12 @@ class basic_socket_acceptor
    * connections. The open() function must be called before the acceptor can
    * accept new socket connections.
    *
-   * @param io_service The io_service object that the acceptor will use to
+   * @param io_context The io_context object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    */
-  explicit basic_socket_acceptor(asio::io_service& io_service)
-    : basic_io_object<SocketAcceptorService>(io_service)
+  explicit basic_socket_acceptor(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
   }
 
@@ -88,7 +109,7 @@ class basic_socket_acceptor
   /**
    * This constructor creates an acceptor and automatically opens it.
    *
-   * @param io_service The io_service object that the acceptor will use to
+   * @param io_context The io_context object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    *
@@ -96,9 +117,9 @@ class basic_socket_acceptor
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_socket_acceptor(asio::io_service& io_service,
+  basic_socket_acceptor(asio::io_context& io_context,
       const protocol_type& protocol)
-    : basic_io_object<SocketAcceptorService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
     this->get_service().open(this->get_implementation(), protocol, ec);
@@ -110,7 +131,7 @@ class basic_socket_acceptor
    * This constructor creates an acceptor and automatically opens it to listen
    * for new connections on the specified endpoint.
    *
-   * @param io_service The io_service object that the acceptor will use to
+   * @param io_context The io_context object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    *
@@ -124,7 +145,7 @@ class basic_socket_acceptor
    *
    * @note This constructor is equivalent to the following code:
    * @code
-   * basic_socket_acceptor<Protocol> acceptor(io_service);
+   * basic_socket_acceptor<Protocol> acceptor(io_context);
    * acceptor.open(endpoint.protocol());
    * if (reuse_addr)
    *   acceptor.set_option(socket_base::reuse_address(true));
@@ -132,9 +153,9 @@ class basic_socket_acceptor
    * acceptor.listen(listen_backlog);
    * @endcode
    */
-  basic_socket_acceptor(asio::io_service& io_service,
+  basic_socket_acceptor(asio::io_context& io_context,
       const endpoint_type& endpoint, bool reuse_addr = true)
-    : basic_io_object<SocketAcceptorService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
     const protocol_type protocol = endpoint.protocol();
@@ -149,7 +170,7 @@ class basic_socket_acceptor
     this->get_service().bind(this->get_implementation(), endpoint, ec);
     asio::detail::throw_error(ec, "bind");
     this->get_service().listen(this->get_implementation(),
-        socket_base::max_connections, ec);
+        socket_base::max_listen_connections, ec);
     asio::detail::throw_error(ec, "listen");
   }
 
@@ -158,7 +179,7 @@ class basic_socket_acceptor
    * This constructor creates an acceptor object to hold an existing native
    * acceptor.
    *
-   * @param io_service The io_service object that the acceptor will use to
+   * @param io_context The io_context object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    *
@@ -168,9 +189,9 @@ class basic_socket_acceptor
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_socket_acceptor(asio::io_service& io_service,
+  basic_socket_acceptor(asio::io_context& io_context,
       const protocol_type& protocol, const native_handle_type& native_acceptor)
-    : basic_io_object<SocketAcceptorService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
     this->get_service().assign(this->get_implementation(),
@@ -187,11 +208,10 @@ class basic_socket_acceptor
    * 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.
+   * constructed using the @c basic_socket_acceptor(io_context&) constructor.
    */
   basic_socket_acceptor(basic_socket_acceptor&& other)
-    : basic_io_object<SocketAcceptorService>(
-        ASIO_MOVE_CAST(basic_socket_acceptor)(other))
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
   {
   }
 
@@ -203,17 +223,16 @@ class basic_socket_acceptor
    * 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.
+   * constructed using the @c basic_socket_acceptor(io_context&) constructor.
    */
   basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
   {
-    basic_io_object<SocketAcceptorService>::operator=(
-        ASIO_MOVE_CAST(basic_socket_acceptor)(other));
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
     return *this;
   }
 
   // All socket acceptors have access to each other's implementations.
-  template <typename Protocol1, typename SocketAcceptorService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   friend class basic_socket_acceptor;
 
   /// Move-construct a basic_socket_acceptor from an acceptor of another
@@ -225,16 +244,15 @@ class basic_socket_acceptor
    * 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.
+   * constructed using the @c basic_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename SocketAcceptorService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   basic_socket_acceptor(
-      basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other,
+      basic_socket_acceptor<Protocol1 ASIO_SVC_TARG1>&& other,
       typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
-    : basic_io_object<SocketAcceptorService>(other.get_io_service())
+    : basic_io_object<ASIO_SVC_T>(
+        other.get_service(), other.get_implementation())
   {
-    this->get_service().template converting_move_construct<Protocol1>(
-        this->get_implementation(), other.get_implementation());
   }
 
   /// Move-assign a basic_socket_acceptor from an acceptor of another protocol
@@ -246,21 +264,69 @@ class basic_socket_acceptor
    * 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.
+   * constructed using the @c basic_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename SocketAcceptorService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   typename enable_if<is_convertible<Protocol1, Protocol>::value,
       basic_socket_acceptor>::type& operator=(
-        basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other)
+        basic_socket_acceptor<Protocol1 ASIO_SVC_TARG1>&& other)
   {
-    basic_socket_acceptor tmp(ASIO_MOVE_CAST2(basic_socket_acceptor<
-            Protocol1, SocketAcceptorService1>)(other));
-    basic_io_object<SocketAcceptorService>::operator=(
-        ASIO_MOVE_CAST(basic_socket_acceptor)(tmp));
+    basic_socket_acceptor tmp(std::move(other));
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(tmp));
     return *this;
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
+  /// Destroys the acceptor.
+  /**
+   * This function destroys the acceptor, cancelling any outstanding
+   * asynchronous operations associated with the acceptor as if by calling
+   * @c cancel.
+   */
+  ~basic_socket_acceptor()
+  {
+  }
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+  // These functions are provided by basic_io_object<>.
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
   /// Open the acceptor using the specified protocol.
   /**
    * This function opens the socket acceptor so that it will use the specified
@@ -272,7 +338,7 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * acceptor.open(asio::ip::tcp::v4());
    * @endcode
    */
@@ -294,7 +360,7 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * asio::error_code ec;
    * acceptor.open(asio::ip::tcp::v4(), ec);
    * if (ec)
@@ -303,10 +369,11 @@ class basic_socket_acceptor
    * }
    * @endcode
    */
-  asio::error_code open(const protocol_type& protocol,
+  ASIO_SYNC_OP_VOID open(const protocol_type& protocol,
       asio::error_code& ec)
   {
-    return this->get_service().open(this->get_implementation(), protocol, ec);
+    this->get_service().open(this->get_implementation(), protocol, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assigns an existing native acceptor to the acceptor.
@@ -338,11 +405,12 @@ class basic_socket_acceptor
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code assign(const protocol_type& protocol,
+  ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,
       const native_handle_type& native_acceptor, asio::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(),
+    this->get_service().assign(this->get_implementation(),
         protocol, native_acceptor, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the acceptor is open.
@@ -363,7 +431,7 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), 12345);
    * acceptor.open(endpoint.protocol());
    * acceptor.bind(endpoint);
@@ -388,7 +456,7 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), 12345);
    * acceptor.open(endpoint.protocol());
    * asio::error_code ec;
@@ -399,10 +467,11 @@ class basic_socket_acceptor
    * }
    * @endcode
    */
-  asio::error_code bind(const endpoint_type& endpoint,
+  ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,
       asio::error_code& ec)
   {
-    return this->get_service().bind(this->get_implementation(), endpoint, ec);
+    this->get_service().bind(this->get_implementation(), endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Place the acceptor into the state where it will listen for new
@@ -415,7 +484,7 @@ class basic_socket_acceptor
    *
    * @throws asio::system_error Thrown on failure.
    */
-  void listen(int backlog = socket_base::max_connections)
+  void listen(int backlog = socket_base::max_listen_connections)
   {
     asio::error_code ec;
     this->get_service().listen(this->get_implementation(), backlog, ec);
@@ -434,19 +503,20 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::error_code ec;
-   * acceptor.listen(asio::socket_base::max_connections, ec);
+   * acceptor.listen(asio::socket_base::max_listen_connections, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
-  asio::error_code listen(int backlog, asio::error_code& ec)
+  ASIO_SYNC_OP_VOID listen(int backlog, asio::error_code& ec)
   {
-    return this->get_service().listen(this->get_implementation(), backlog, ec);
+    this->get_service().listen(this->get_implementation(), backlog, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Close the acceptor.
@@ -478,7 +548,7 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::error_code ec;
    * acceptor.close(ec);
@@ -488,20 +558,62 @@ class basic_socket_acceptor
    * }
    * @endcode
    */
-  asio::error_code close(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native acceptor representation.
+  /// Release ownership of the underlying native acceptor.
   /**
-   * 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.
+   * This function causes all outstanding asynchronous accept operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error. Ownership of the
+   * native acceptor is then transferred to the caller.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with asio::error::operation_not_supported on
+   * these platforms.
    */
-  native_type native()
+#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release()
   {
-    return this->get_service().native_handle(this->get_implementation());
+    asio::error_code ec;
+    native_handle_type s = this->get_service().release(
+        this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "release");
+    return s;
+  }
+
+  /// Release ownership of the underlying native acceptor.
+  /**
+   * This function causes all outstanding asynchronous accept operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error. Ownership of the
+   * native acceptor is then transferred to the caller.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release(asio::error_code& ec)
+  {
+    return this->get_service().release(this->get_implementation(), ec);
   }
 
   /// Get the native acceptor representation.
@@ -538,9 +650,10 @@ class basic_socket_acceptor
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code cancel(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Set an option on the acceptor.
@@ -558,7 +671,7 @@ class basic_socket_acceptor
    * @par Example
    * Setting the SOL_SOCKET/SO_REUSEADDR option:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::ip::tcp::acceptor::reuse_address option(true);
    * acceptor.set_option(option);
@@ -587,7 +700,7 @@ class basic_socket_acceptor
    * @par Example
    * Setting the SOL_SOCKET/SO_REUSEADDR option:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::ip::tcp::acceptor::reuse_address option(true);
    * asio::error_code ec;
@@ -599,11 +712,11 @@ class basic_socket_acceptor
    * @endcode
    */
   template <typename SettableSocketOption>
-  asio::error_code set_option(const SettableSocketOption& option,
+  ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,
       asio::error_code& ec)
   {
-    return this->get_service().set_option(
-        this->get_implementation(), option, ec);
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get an option from the acceptor.
@@ -621,7 +734,7 @@ class basic_socket_acceptor
    * @par Example
    * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::ip::tcp::acceptor::reuse_address option;
    * acceptor.get_option(option);
@@ -629,7 +742,7 @@ class basic_socket_acceptor
    * @endcode
    */
   template <typename GettableSocketOption>
-  void get_option(GettableSocketOption& option)
+  void get_option(GettableSocketOption& option) const
   {
     asio::error_code ec;
     this->get_service().get_option(this->get_implementation(), option, ec);
@@ -651,7 +764,7 @@ class basic_socket_acceptor
    * @par Example
    * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::ip::tcp::acceptor::reuse_address option;
    * asio::error_code ec;
@@ -664,11 +777,11 @@ class basic_socket_acceptor
    * @endcode
    */
   template <typename GettableSocketOption>
-  asio::error_code get_option(GettableSocketOption& option,
-      asio::error_code& ec)
+  ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,
+      asio::error_code& ec) const
   {
-    return this->get_service().get_option(
-        this->get_implementation(), option, ec);
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the acceptor.
@@ -685,7 +798,7 @@ class basic_socket_acceptor
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::ip::tcp::acceptor::non_blocking_io command(true);
    * socket.io_control(command);
@@ -713,7 +826,7 @@ class basic_socket_acceptor
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::ip::tcp::acceptor::non_blocking_io command(true);
    * asio::error_code ec;
@@ -725,11 +838,11 @@ class basic_socket_acceptor
    * @endcode
    */
   template <typename IoControlCommand>
-  asio::error_code io_control(IoControlCommand& command,
+  ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
       asio::error_code& ec)
   {
-    return this->get_service().io_control(
-        this->get_implementation(), command, ec);
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the acceptor.
@@ -781,11 +894,11 @@ class basic_socket_acceptor
    * operations. Asynchronous operations will never fail with the error
    * asio::error::would_block.
    */
-  asio::error_code non_blocking(
+  ASIO_SYNC_OP_VOID non_blocking(
       bool mode, asio::error_code& ec)
   {
-    return this->get_service().non_blocking(
-        this->get_implementation(), mode, ec);
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native acceptor implementation.
@@ -845,11 +958,12 @@ class basic_socket_acceptor
    * function fails with asio::error::invalid_argument, as the
    * combination does not make sense.
    */
-  asio::error_code native_non_blocking(
+  ASIO_SYNC_OP_VOID native_non_blocking(
       bool mode, asio::error_code& ec)
   {
-    return this->get_service().native_non_blocking(
+    this->get_service().native_non_blocking(
         this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the local endpoint of the acceptor.
@@ -862,7 +976,7 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint();
    * @endcode
@@ -888,7 +1002,7 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
    * asio::error_code ec;
    * asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint(ec);
@@ -903,6 +1017,116 @@ class basic_socket_acceptor
     return this->get_service().local_endpoint(this->get_implementation(), ec);
   }
 
+  /// Wait for the acceptor to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for an acceptor to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired acceptor state.
+   *
+   * @par Example
+   * Waiting for an acceptor to become readable.
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * acceptor.wait(asio::ip::tcp::acceptor::wait_read);
+   * @endcode
+   */
+  void wait(wait_type w)
+  {
+    asio::error_code ec;
+    this->get_service().wait(this->get_implementation(), w, ec);
+    asio::detail::throw_error(ec, "wait");
+  }
+
+  /// Wait for the acceptor to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for an acceptor to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired acceptor state.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * Waiting for an acceptor to become readable.
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::error_code ec;
+   * acceptor.wait(asio::ip::tcp::acceptor::wait_read, ec);
+   * @endcode
+   */
+  ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
+  {
+    this->get_service().wait(this->get_implementation(), w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the acceptor to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  /**
+   * This function is used to perform an asynchronous wait for an acceptor to
+   * enter a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired acceptor state.
+   *
+   * @param handler The handler to be called when the wait operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error // Result of operation
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void wait_handler(const asio::error_code& error)
+   * {
+   *   if (!error)
+   *   {
+   *     // Wait succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * acceptor.async_wait(
+   *     asio::ip::tcp::acceptor::wait_read,
+   *     wait_handler);
+   * @endcode
+   */
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(wait_type w, ASIO_MOVE_ARG(WaitHandler) 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.
+    ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_wait(this->get_implementation(),
+        w, ASIO_MOVE_CAST(WaitHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_wait(this->get_implementation(),
+        w, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+
+#if !defined(ASIO_NO_EXTENSIONS)
   /// Accept a new connection.
   /**
    * This function is used to accept a new connection from a peer into the
@@ -915,15 +1139,21 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * acceptor.accept(socket);
    * @endcode
    */
+#if defined(ASIO_ENABLE_OLD_SERVICES)
   template <typename Protocol1, typename SocketService>
   void accept(basic_socket<Protocol1, SocketService>& peer,
       typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+  template <typename Protocol1>
+  void accept(basic_socket<Protocol1>& peer,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   {
     asio::error_code ec;
     this->get_service().accept(this->get_implementation(),
@@ -943,9 +1173,9 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
-   * asio::ip::tcp::soocket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * asio::error_code ec;
    * acceptor.accept(socket, ec);
    * if (ec)
@@ -954,14 +1184,22 @@ class basic_socket_acceptor
    * }
    * @endcode
    */
+#if defined(ASIO_ENABLE_OLD_SERVICES)
   template <typename Protocol1, typename SocketService>
-  asio::error_code accept(
+  ASIO_SYNC_OP_VOID accept(
       basic_socket<Protocol1, SocketService>& peer,
       asio::error_code& ec,
       typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+  template <typename Protocol1>
+  ASIO_SYNC_OP_VOID accept(
+      basic_socket<Protocol1>& peer, asio::error_code& ec,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   {
-    return this->get_service().accept(this->get_implementation(),
+    this->get_service().accept(this->get_implementation(),
         peer, static_cast<endpoint_type*>(0), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous accept.
@@ -982,7 +1220,7 @@ class basic_socket_acceptor
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @par Example
    * @code
@@ -996,26 +1234,45 @@ class basic_socket_acceptor
    *
    * ...
    *
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * acceptor.async_accept(socket, accept_handler);
    * @endcode
    */
+#if defined(ASIO_ENABLE_OLD_SERVICES)
   template <typename Protocol1, typename SocketService, typename AcceptHandler>
   ASIO_INITFN_RESULT_TYPE(AcceptHandler,
       void (asio::error_code))
   async_accept(basic_socket<Protocol1, SocketService>& peer,
       ASIO_MOVE_ARG(AcceptHandler) handler,
       typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+  template <typename Protocol1, typename AcceptHandler>
+  ASIO_INITFN_RESULT_TYPE(AcceptHandler,
+      void (asio::error_code))
+  async_accept(basic_socket<Protocol1>& peer,
+      ASIO_MOVE_ARG(AcceptHandler) handler,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a AcceptHandler.
     ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_accept(this->get_implementation(),
         peer, static_cast<endpoint_type*>(0),
         ASIO_MOVE_CAST(AcceptHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<AcceptHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_accept(this->get_implementation(),
+        peer, static_cast<endpoint_type*>(0), init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Accept a new connection and obtain the endpoint of the peer
@@ -1034,16 +1291,20 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * asio::ip::tcp::endpoint endpoint;
    * acceptor.accept(socket, endpoint);
    * @endcode
    */
+#if defined(ASIO_ENABLE_OLD_SERVICES)
   template <typename SocketService>
   void accept(basic_socket<protocol_type, SocketService>& peer,
       endpoint_type& peer_endpoint)
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+  void accept(basic_socket<protocol_type>& peer, endpoint_type& peer_endpoint)
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   {
     asio::error_code ec;
     this->get_service().accept(this->get_implementation(),
@@ -1067,9 +1328,9 @@ class basic_socket_acceptor
    *
    * @par Example
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
+   * asio::ip::tcp::acceptor acceptor(io_context);
    * ...
-   * asio::ip::tcp::socket socket(io_service);
+   * asio::ip::tcp::socket socket(io_context);
    * asio::ip::tcp::endpoint endpoint;
    * asio::error_code ec;
    * acceptor.accept(socket, endpoint, ec);
@@ -1079,13 +1340,19 @@ class basic_socket_acceptor
    * }
    * @endcode
    */
+#if defined(ASIO_ENABLE_OLD_SERVICES)
   template <typename SocketService>
-  asio::error_code accept(
+  ASIO_SYNC_OP_VOID accept(
       basic_socket<protocol_type, SocketService>& peer,
       endpoint_type& peer_endpoint, asio::error_code& ec)
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+  ASIO_SYNC_OP_VOID accept(basic_socket<protocol_type>& peer,
+      endpoint_type& peer_endpoint, asio::error_code& ec)
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   {
-    return this->get_service().accept(
+    this->get_service().accept(
         this->get_implementation(), peer, &peer_endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous accept.
@@ -1112,25 +1379,608 @@ class basic_socket_acceptor
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
+#if defined(ASIO_ENABLE_OLD_SERVICES)
   template <typename SocketService, typename AcceptHandler>
   ASIO_INITFN_RESULT_TYPE(AcceptHandler,
       void (asio::error_code))
   async_accept(basic_socket<protocol_type, SocketService>& peer,
       endpoint_type& peer_endpoint, ASIO_MOVE_ARG(AcceptHandler) handler)
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+  template <typename AcceptHandler>
+  ASIO_INITFN_RESULT_TYPE(AcceptHandler,
+      void (asio::error_code))
+  async_accept(basic_socket<protocol_type>& peer,
+      endpoint_type& peer_endpoint, ASIO_MOVE_ARG(AcceptHandler) handler)
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a AcceptHandler.
     ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_accept(this->get_implementation(), peer,
         &peer_endpoint, ASIO_MOVE_CAST(AcceptHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<AcceptHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_accept(this->get_implementation(),
+        peer, &peer_endpoint, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @returns A socket object representing the newly accepted connection.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::socket socket(acceptor.accept());
+   * @endcode
+   */
+  typename Protocol::socket accept()
+  {
+    asio::error_code ec;
+    typename Protocol::socket peer(
+        this->get_service().accept(
+          this->get_implementation(), 0, 0, ec));
+    asio::detail::throw_error(ec, "accept");
+    return peer;
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns On success, a socket object representing the newly accepted
+   * connection. On error, a socket object where is_open() is false.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::socket socket(acceptor.accept(ec));
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  typename Protocol::socket accept(asio::error_code& ec)
+  {
+    return this->get_service().accept(this->get_implementation(), 0, 0, ec);
+  }
+
+  /// Start an asynchronous accept.
+  /**
+   * This function is used to asynchronously accept a new connection. The
+   * function call always returns immediately.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param handler The handler to be called when the accept operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   typename Protocol::socket peer // On success, the newly accepted socket.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void accept_handler(const asio::error_code& error,
+   *     asio::ip::tcp::socket peer)
+   * {
+   *   if (!error)
+   *   {
+   *     // Accept succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * acceptor.async_accept(accept_handler);
+   * @endcode
+   */
+  template <typename MoveAcceptHandler>
+  ASIO_INITFN_RESULT_TYPE(MoveAcceptHandler,
+      void (asio::error_code, typename Protocol::socket))
+  async_accept(ASIO_MOVE_ARG(MoveAcceptHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a MoveAcceptHandler.
+    ASIO_MOVE_ACCEPT_HANDLER_CHECK(MoveAcceptHandler,
+        handler, typename Protocol::socket) type_check;
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_accept(
+        this->get_implementation(), static_cast<asio::io_context*>(0),
+        static_cast<endpoint_type*>(0),
+        ASIO_MOVE_CAST(MoveAcceptHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<MoveAcceptHandler,
+      void (asio::error_code,
+        typename Protocol::socket)> init(handler);
+
+    this->get_service().async_accept(
+        this->get_implementation(), static_cast<asio::io_context*>(0),
+        static_cast<endpoint_type*>(0), init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param io_context The io_context object to be used for the newly accepted
+   * socket.
+   *
+   * @returns A socket object representing the newly accepted connection.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::socket socket(acceptor.accept());
+   * @endcode
+   */
+  typename Protocol::socket accept(asio::io_context& io_context)
+  {
+    asio::error_code ec;
+    typename Protocol::socket peer(
+        this->get_service().accept(this->get_implementation(),
+          &io_context, static_cast<endpoint_type*>(0), ec));
+    asio::detail::throw_error(ec, "accept");
+    return peer;
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param io_context The io_context object to be used for the newly accepted
+   * socket.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns On success, a socket object representing the newly accepted
+   * connection. On error, a socket object where is_open() is false.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::socket socket(acceptor.accept(io_context2, ec));
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  typename Protocol::socket accept(
+      asio::io_context& io_context, asio::error_code& ec)
+  {
+    return this->get_service().accept(this->get_implementation(),
+        &io_context, static_cast<endpoint_type*>(0), ec);
+  }
+
+  /// Start an asynchronous accept.
+  /**
+   * This function is used to asynchronously accept a new connection. The
+   * function call always returns immediately.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param io_context The io_context object to be used for the newly accepted
+   * socket.
+   *
+   * @param handler The handler to be called when the accept operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   typename Protocol::socket peer // On success, the newly accepted socket.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void accept_handler(const asio::error_code& error,
+   *     asio::ip::tcp::socket peer)
+   * {
+   *   if (!error)
+   *   {
+   *     // Accept succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * acceptor.async_accept(io_context2, accept_handler);
+   * @endcode
+   */
+  template <typename MoveAcceptHandler>
+  ASIO_INITFN_RESULT_TYPE(MoveAcceptHandler,
+      void (asio::error_code, typename Protocol::socket))
+  async_accept(asio::io_context& io_context,
+      ASIO_MOVE_ARG(MoveAcceptHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a MoveAcceptHandler.
+    ASIO_MOVE_ACCEPT_HANDLER_CHECK(MoveAcceptHandler,
+        handler, typename Protocol::socket) type_check;
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_accept(this->get_implementation(),
+        &io_context, static_cast<endpoint_type*>(0),
+        ASIO_MOVE_CAST(MoveAcceptHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<MoveAcceptHandler,
+      void (asio::error_code,
+        typename Protocol::socket)> init(handler);
+
+    this->get_service().async_accept(this->get_implementation(),
+        &io_context, static_cast<endpoint_type*>(0), init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param peer_endpoint An endpoint object into which the endpoint of the
+   * remote peer will be written.
+   *
+   * @returns A socket object representing the newly accepted connection.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::endpoint endpoint;
+   * asio::ip::tcp::socket socket(acceptor.accept(endpoint));
+   * @endcode
+   */
+  typename Protocol::socket accept(endpoint_type& peer_endpoint)
+  {
+    asio::error_code ec;
+    typename Protocol::socket peer(
+        this->get_service().accept(this->get_implementation(),
+          static_cast<asio::io_context*>(0), &peer_endpoint, ec));
+    asio::detail::throw_error(ec, "accept");
+    return peer;
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param peer_endpoint An endpoint object into which the endpoint of the
+   * remote peer will be written.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns On success, a socket object representing the newly accepted
+   * connection. On error, a socket object where is_open() is false.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::endpoint endpoint;
+   * asio::ip::tcp::socket socket(acceptor.accept(endpoint, ec));
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  typename Protocol::socket accept(
+      endpoint_type& peer_endpoint, asio::error_code& ec)
+  {
+    return this->get_service().accept(this->get_implementation(),
+        static_cast<asio::io_context*>(0), &peer_endpoint, ec);
+  }
+
+  /// Start an asynchronous accept.
+  /**
+   * This function is used to asynchronously accept a new connection. The
+   * function call always returns immediately.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param peer_endpoint An endpoint object into which the endpoint of the
+   * remote peer will be written. Ownership of the peer_endpoint object is
+   * retained by the caller, which must guarantee that it is valid until the
+   * handler is called.
+   *
+   * @param handler The handler to be called when the accept operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   typename Protocol::socket peer // On success, the newly accepted socket.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void accept_handler(const asio::error_code& error,
+   *     asio::ip::tcp::socket peer)
+   * {
+   *   if (!error)
+   *   {
+   *     // Accept succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::endpoint endpoint;
+   * acceptor.async_accept(endpoint, accept_handler);
+   * @endcode
+   */
+  template <typename MoveAcceptHandler>
+  ASIO_INITFN_RESULT_TYPE(MoveAcceptHandler,
+      void (asio::error_code, typename Protocol::socket))
+  async_accept(endpoint_type& peer_endpoint,
+      ASIO_MOVE_ARG(MoveAcceptHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a MoveAcceptHandler.
+    ASIO_MOVE_ACCEPT_HANDLER_CHECK(MoveAcceptHandler,
+        handler, typename Protocol::socket) type_check;
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_accept(this->get_implementation(),
+        static_cast<asio::io_context*>(0), &peer_endpoint,
+        ASIO_MOVE_CAST(MoveAcceptHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<MoveAcceptHandler,
+      void (asio::error_code,
+        typename Protocol::socket)> init(handler);
+
+    this->get_service().async_accept(this->get_implementation(),
+        static_cast<asio::io_context*>(0), &peer_endpoint,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param io_context The io_context object to be used for the newly accepted
+   * socket.
+   *
+   * @param peer_endpoint An endpoint object into which the endpoint of the
+   * remote peer will be written.
+   *
+   * @returns A socket object representing the newly accepted connection.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::endpoint endpoint;
+   * asio::ip::tcp::socket socket(
+   *     acceptor.accept(io_context2, endpoint));
+   * @endcode
+   */
+  typename Protocol::socket accept(
+      asio::io_context& io_context, endpoint_type& peer_endpoint)
+  {
+    asio::error_code ec;
+    typename Protocol::socket peer(
+        this->get_service().accept(this->get_implementation(),
+          &io_context, &peer_endpoint, ec));
+    asio::detail::throw_error(ec, "accept");
+    return peer;
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer. The function
+   * call will block until a new connection has been accepted successfully or
+   * an error occurs.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param io_context The io_context object to be used for the newly accepted
+   * socket.
+   *
+   * @param peer_endpoint An endpoint object into which the endpoint of the
+   * remote peer will be written.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns On success, a socket object representing the newly accepted
+   * connection. On error, a socket object where is_open() is false.
+   *
+   * @par Example
+   * @code
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::endpoint endpoint;
+   * asio::ip::tcp::socket socket(
+   *     acceptor.accept(io_context2, endpoint, ec));
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  typename Protocol::socket accept(asio::io_context& io_context,
+      endpoint_type& peer_endpoint, asio::error_code& ec)
+  {
+    return this->get_service().accept(this->get_implementation(),
+        &io_context, &peer_endpoint, ec);
+  }
+
+  /// Start an asynchronous accept.
+  /**
+   * This function is used to asynchronously accept a new connection. The
+   * function call always returns immediately.
+   *
+   * This overload requires that the Protocol template parameter satisfy the
+   * AcceptableProtocol type requirements.
+   *
+   * @param io_context The io_context object to be used for the newly accepted
+   * socket.
+   *
+   * @param peer_endpoint An endpoint object into which the endpoint of the
+   * remote peer will be written. Ownership of the peer_endpoint object is
+   * retained by the caller, which must guarantee that it is valid until the
+   * handler is called.
+   *
+   * @param handler The handler to be called when the accept operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   typename Protocol::socket peer // On success, the newly accepted socket.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void accept_handler(const asio::error_code& error,
+   *     asio::ip::tcp::socket peer)
+   * {
+   *   if (!error)
+   *   {
+   *     // Accept succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::ip::tcp::acceptor acceptor(io_context);
+   * ...
+   * asio::ip::tcp::endpoint endpoint;
+   * acceptor.async_accept(io_context2, endpoint, accept_handler);
+   * @endcode
+   */
+  template <typename MoveAcceptHandler>
+  ASIO_INITFN_RESULT_TYPE(MoveAcceptHandler,
+      void (asio::error_code, typename Protocol::socket))
+  async_accept(asio::io_context& io_context,
+      endpoint_type& peer_endpoint,
+      ASIO_MOVE_ARG(MoveAcceptHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a MoveAcceptHandler.
+    ASIO_MOVE_ACCEPT_HANDLER_CHECK(MoveAcceptHandler,
+        handler, typename Protocol::socket) type_check;
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_accept(
+        this->get_implementation(), &io_context, &peer_endpoint,
+        ASIO_MOVE_CAST(MoveAcceptHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<MoveAcceptHandler,
+      void (asio::error_code,
+        typename Protocol::socket)> init(handler);
+
+    this->get_service().async_accept(this->get_implementation(),
+        &io_context, &peer_endpoint, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 };
 
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# undef ASIO_SVC_T
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_BASIC_SOCKET_ACCEPTOR_HPP
diff --git a/extern/include/asio/basic_socket_iostream.hpp b/extern/include/asio/basic_socket_iostream.hpp
index c25d4c57..6681367f 100644
--- a/extern/include/asio/basic_socket_iostream.hpp
+++ b/extern/include/asio/basic_socket_iostream.hpp
@@ -2,7 +2,7 @@
 // basic_socket_iostream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,7 +22,10 @@
 #include <istream>
 #include <ostream>
 #include "asio/basic_socket_streambuf.hpp"
-#include "asio/stream_socket_service.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/stream_socket_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 #if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
 
@@ -33,8 +36,8 @@
 //   explicit basic_socket_iostream(T1 x1, ..., Tn xn)
 //     : std::basic_iostream<char>(
 //         &this->detail::socket_iostream_base<
-//           Protocol, StreamSocketService, Time,
-//           TimeTraits, TimerService>::streambuf_)
+//           Protocol ASIO_SVC_TARG, Clock,
+//           WaitTraits ASIO_SVC_TARG1>::streambuf_)
 //   {
 //     if (rdbuf()->connect(x1, ..., xn) == 0)
 //       this->setstate(std::ios_base::failbit);
@@ -43,14 +46,14 @@
 
 # define ASIO_PRIVATE_CTR_DEF(n) \
   template <ASIO_VARIADIC_TPARAMS(n)> \
-  explicit basic_socket_iostream(ASIO_VARIADIC_PARAMS(n)) \
+  explicit basic_socket_iostream(ASIO_VARIADIC_BYVAL_PARAMS(n)) \
     : std::basic_iostream<char>( \
         &this->detail::socket_iostream_base< \
-          Protocol, StreamSocketService, Time, \
-          TimeTraits, TimerService>::streambuf_) \
+          Protocol ASIO_SVC_TARG, Clock, \
+          WaitTraits ASIO_SVC_TARG1>::streambuf_) \
   { \
     this->setf(std::ios_base::unitbuf); \
-    if (rdbuf()->connect(ASIO_VARIADIC_ARGS(n)) == 0) \
+    if (rdbuf()->connect(ASIO_VARIADIC_BYVAL_ARGS(n)) == 0) \
       this->setstate(std::ios_base::failbit); \
   } \
   /**/
@@ -66,9 +69,9 @@
 
 # define ASIO_PRIVATE_CONNECT_DEF(n) \
   template <ASIO_VARIADIC_TPARAMS(n)> \
-  void connect(ASIO_VARIADIC_PARAMS(n)) \
+  void connect(ASIO_VARIADIC_BYVAL_PARAMS(n)) \
   { \
-    if (rdbuf()->connect(ASIO_VARIADIC_ARGS(n)) == 0) \
+    if (rdbuf()->connect(ASIO_VARIADIC_BYVAL_ARGS(n)) == 0) \
       this->setstate(std::ios_base::failbit); \
   } \
   /**/
@@ -82,69 +85,169 @@ namespace detail {
 
 // A separate base class is used to ensure that the streambuf is initialised
 // prior to the basic_socket_iostream's basic_iostream base class.
-template <typename Protocol, typename StreamSocketService,
-    typename Time, typename TimeTraits, typename TimerService>
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Clock, typename WaitTraits ASIO_SVC_TPARAM1>
 class socket_iostream_base
 {
 protected:
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService> streambuf_;
+  socket_iostream_base()
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  socket_iostream_base(socket_iostream_base&& other)
+    : streambuf_(std::move(other.streambuf_))
+  {
+  }
+
+  socket_iostream_base(basic_stream_socket<Protocol> s)
+    : streambuf_(std::move(s))
+  {
+  }
+
+  socket_iostream_base& operator=(socket_iostream_base&& other)
+  {
+    streambuf_ = std::move(other.streambuf_);
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  basic_socket_streambuf<Protocol ASIO_SVC_TARG,
+    Clock, WaitTraits ASIO_SVC_TARG1> streambuf_;
 };
 
-}
+} // namespace detail
+
+#if !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
+#define ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= stream_socket_service<Protocol>),
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+    typename Clock = boost::posix_time::ptime,
+    typename WaitTraits = time_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF2(= deadline_timer_service<Clock, WaitTraits>)>
+#else // defined(ASIO_HAS_BOOST_DATE_TIME)
+      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+    typename Clock = chrono::steady_clock,
+    typename WaitTraits = wait_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF1(= steady_timer::service_type)>
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+class basic_socket_iostream;
+
+#endif // !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
 
 /// Iostream interface for a socket.
+#if defined(GENERATING_DOCUMENTATION)
 template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol>,
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  || defined(GENERATING_DOCUMENTATION)
-    typename Time = boost::posix_time::ptime,
-    typename TimeTraits = asio::time_traits<Time>,
-    typename TimerService = deadline_timer_service<Time, TimeTraits> >
-#else
-    typename Time = steady_timer::clock_type,
-    typename TimeTraits = steady_timer::traits_type,
-    typename TimerService = steady_timer::service_type>
-#endif
+    typename Clock = chrono::steady_clock,
+    typename WaitTraits = wait_traits<Clock> >
+#else // defined(GENERATING_DOCUMENTATION)
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Clock, typename WaitTraits ASIO_SVC_TPARAM1>
+#endif // defined(GENERATING_DOCUMENTATION)
 class basic_socket_iostream
-  : private detail::socket_iostream_base<Protocol,
-        StreamSocketService, Time, TimeTraits, TimerService>,
+  : private detail::socket_iostream_base<Protocol
+        ASIO_SVC_TARG, Clock, WaitTraits ASIO_SVC_TARG1>,
     public std::basic_iostream<char>
 {
 private:
   // These typedefs are intended keep this class's implementation independent
-  // of whether it's using Boost.DateTime, Boost.Chrono or std::chrono.
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-  typedef TimeTraits traits_helper;
-#else
-  typedef detail::chrono_time_traits<Time, TimeTraits> traits_helper;
-#endif
+  // of whether it's using Boost.DateClock, Boost.Chrono or std::chrono.
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+  typedef WaitTraits traits_helper;
+#else // defined(ASIO_HAS_BOOST_DATE_TIME)
+      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+  typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
 
 public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
+  /// The clock type.
+  typedef Clock clock_type;
+
 #if defined(GENERATING_DOCUMENTATION)
+  /// (Deprecated: Use time_point.) The time type.
+  typedef typename WaitTraits::time_type time_type;
+
   /// The time type.
-  typedef typename TimeTraits::time_type time_type;
+  typedef typename WaitTraits::time_point time_point;
+
+  /// (Deprecated: Use duration.) The duration type.
+  typedef typename WaitTraits::duration_type duration_type;
 
   /// The duration type.
-  typedef typename TimeTraits::duration_type duration_type;
+  typedef typename WaitTraits::duration duration;
 #else
+# if !defined(ASIO_NO_DEPRECATED)
   typedef typename traits_helper::time_type time_type;
   typedef typename traits_helper::duration_type duration_type;
+# endif // !defined(ASIO_NO_DEPRECATED)
+  typedef typename traits_helper::time_type time_point;
+  typedef typename traits_helper::duration_type duration;
 #endif
 
   /// Construct a basic_socket_iostream without establishing a connection.
   basic_socket_iostream()
     : std::basic_iostream<char>(
         &this->detail::socket_iostream_base<
-          Protocol, StreamSocketService, Time,
-          TimeTraits, TimerService>::streambuf_)
+          Protocol ASIO_SVC_TARG, Clock,
+          WaitTraits ASIO_SVC_TARG1>::streambuf_)
+  {
+    this->setf(std::ios_base::unitbuf);
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Construct a basic_socket_iostream from the supplied socket.
+  explicit basic_socket_iostream(basic_stream_socket<protocol_type> s)
+    : detail::socket_iostream_base<
+        Protocol ASIO_SVC_TARG, Clock,
+        WaitTraits ASIO_SVC_TARG1>(std::move(s)),
+      std::basic_iostream<char>(
+        &this->detail::socket_iostream_base<
+          Protocol ASIO_SVC_TARG, Clock,
+          WaitTraits ASIO_SVC_TARG1>::streambuf_)
   {
     this->setf(std::ios_base::unitbuf);
   }
 
+#if defined(ASIO_HAS_STD_IOSTREAM_MOVE) \
+  || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_socket_iostream from another.
+  basic_socket_iostream(basic_socket_iostream&& other)
+    : detail::socket_iostream_base<
+        Protocol ASIO_SVC_TARG, Clock,
+        WaitTraits ASIO_SVC_TARG1>(std::move(other)),
+      std::basic_iostream<char>(std::move(other))
+  {
+    this->set_rdbuf(&this->detail::socket_iostream_base<
+          Protocol ASIO_SVC_TARG, Clock,
+          WaitTraits ASIO_SVC_TARG1>::streambuf_);
+  }
+
+  /// Move-assign a basic_socket_iostream from another.
+  basic_socket_iostream& operator=(basic_socket_iostream&& other)
+  {
+    std::basic_iostream<char>::operator=(std::move(other));
+    detail::socket_iostream_base<
+        Protocol ASIO_SVC_TARG, Clock,
+        WaitTraits ASIO_SVC_TARG1>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_STD_IOSTREAM_MOVE)
+       //   || defined(GENERATING_DOCUMENTATION)
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
 #if defined(GENERATING_DOCUMENTATION)
   /// Establish a connection to an endpoint corresponding to a resolver query.
   /**
@@ -159,8 +262,8 @@ class basic_socket_iostream
   explicit basic_socket_iostream(T... x)
     : std::basic_iostream<char>(
         &this->detail::socket_iostream_base<
-          Protocol, StreamSocketService, Time,
-          TimeTraits, TimerService>::streambuf_)
+          Protocol ASIO_SVC_TARG, Clock,
+          WaitTraits ASIO_SVC_TARG1>::streambuf_)
   {
     this->setf(std::ios_base::unitbuf);
     if (rdbuf()->connect(x...) == 0)
@@ -198,14 +301,20 @@ class basic_socket_iostream
   }
 
   /// Return a pointer to the underlying streambuf.
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* rdbuf() const
+  basic_socket_streambuf<Protocol ASIO_SVC_TARG,
+    Clock, WaitTraits ASIO_SVC_TARG1>* rdbuf() const
   {
-    return const_cast<basic_socket_streambuf<Protocol, StreamSocketService,
-      Time, TimeTraits, TimerService>*>(
+    return const_cast<basic_socket_streambuf<Protocol ASIO_SVC_TARG,
+      Clock, WaitTraits ASIO_SVC_TARG1>*>(
         &this->detail::socket_iostream_base<
-          Protocol, StreamSocketService, Time,
-          TimeTraits, TimerService>::streambuf_);
+          Protocol ASIO_SVC_TARG, Clock,
+          WaitTraits ASIO_SVC_TARG1>::streambuf_);
+  }
+
+  /// Get a reference to the underlying socket.
+  basic_socket<Protocol ASIO_SVC_TARG>& socket()
+  {
+    return rdbuf()->socket();
   }
 
   /// Get the last error associated with the stream.
@@ -222,17 +331,29 @@ class basic_socket_iostream
    */
   const asio::error_code& error() const
   {
-    return rdbuf()->puberror();
+    return rdbuf()->error();
   }
 
-  /// Get the stream's expiry time as an absolute time.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use expiry().) 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
+  time_point expires_at() const
   {
     return rdbuf()->expires_at();
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the stream's expiry time as an absolute time.
+  /**
+   * @return An absolute time value representing the stream's expiry time.
+   */
+  time_point expiry() const
+  {
+    return rdbuf()->expiry();
+  }
 
   /// Set the stream's expiry time as an absolute time.
   /**
@@ -243,21 +364,37 @@ class basic_socket_iostream
    *
    * @param expiry_time The expiry time to be used for the stream.
    */
-  void expires_at(const time_type& expiry_time)
+  void expires_at(const time_point& expiry_time)
   {
     rdbuf()->expires_at(expiry_time);
   }
 
-  /// Get the timer's expiry time relative to 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
+   * asio::error::operation_aborted.
+   *
+   * @param expiry_time The expiry time to be used for the timer.
+   */
+  void expires_after(const duration& expiry_time)
+  {
+    rdbuf()->expires_after(expiry_time);
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use expiry().) Get the stream's expiry time relative to now.
   /**
    * @return A relative time value representing the stream's expiry time.
    */
-  duration_type expires_from_now() const
+  duration expires_from_now() const
   {
     return rdbuf()->expires_from_now();
   }
 
-  /// Set the stream's expiry time relative to now.
+  /// (Deprecated: Use expires_after().) 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
@@ -266,10 +403,17 @@ class basic_socket_iostream
    *
    * @param expiry_time The expiry time to be used for the timer.
    */
-  void expires_from_now(const duration_type& expiry_time)
+  void expires_from_now(const duration& expiry_time)
   {
     rdbuf()->expires_from_now(expiry_time);
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+private:
+  // Disallow copying and assignment.
+  basic_socket_iostream(const basic_socket_iostream&) ASIO_DELETED;
+  basic_socket_iostream& operator=(
+      const basic_socket_iostream&) ASIO_DELETED;
 };
 
 } // namespace asio
diff --git a/extern/include/asio/basic_socket_streambuf.hpp b/extern/include/asio/basic_socket_streambuf.hpp
index ed39b1f4..56a3637d 100644
--- a/extern/include/asio/basic_socket_streambuf.hpp
+++ b/extern/include/asio/basic_socket_streambuf.hpp
@@ -2,7 +2,7 @@
 // basic_socket_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,18 +20,30 @@
 #if !defined(ASIO_NO_IOSTREAM)
 
 #include <streambuf>
+#include <vector>
 #include "asio/basic_socket.hpp"
-#include "asio/deadline_timer_service.hpp"
-#include "asio/detail/array.hpp"
+#include "asio/basic_stream_socket.hpp"
+#include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/throw_error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/stream_socket_service.hpp"
+#include "asio/io_context.hpp"
 
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/deadline_timer.hpp"
-#else
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/stream_socket_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+# if defined(ASIO_ENABLE_OLD_SERVICES)
+#  include "asio/deadline_timer_service.hpp"
+# else // defined(ASIO_ENABLE_OLD_SERVICES)
+#  include "asio/detail/deadline_timer_service.hpp"
+# endif // defined(ASIO_ENABLE_OLD_SERVICES)
+#else // defined(ASIO_HAS_BOOST_DATE_TIME)
+      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
 # include "asio/steady_timer.hpp"
-#endif
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
 
 #if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
 
@@ -39,112 +51,219 @@
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
-//   basic_socket_streambuf<Protocol, StreamSocketService,
-//     Time, TimeTraits, TimerService>* connect(
-//       T1 x1, ..., Tn xn)
+//   basic_socket_streambuf* connect(T1 x1, ..., Tn xn)
 //   {
 //     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(x1, ..., xn);
-//     resolve_and_connect(query);
+//     resolver_type resolver(socket().get_executor().context());
+//     connect_to_endpoints(
+//         resolver.resolve(x1, ..., xn, ec_));
 //     return !ec_ ? this : 0;
 //   }
 // This macro should only persist within this file.
 
 # define ASIO_PRIVATE_CONNECT_DEF(n) \
   template <ASIO_VARIADIC_TPARAMS(n)> \
-  basic_socket_streambuf<Protocol, StreamSocketService, \
-    Time, TimeTraits, TimerService>* connect(ASIO_VARIADIC_PARAMS(n)) \
+  basic_socket_streambuf* connect(ASIO_VARIADIC_BYVAL_PARAMS(n)) \
   { \
     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(ASIO_VARIADIC_ARGS(n)); \
-    resolve_and_connect(query); \
+    resolver_type resolver(socket().get_executor().context()); \
+    connect_to_endpoints( \
+        resolver.resolve(ASIO_VARIADIC_BYVAL_ARGS(n), ec_)); \
     return !ec_ ? this : 0; \
   } \
   /**/
 
 #endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
 
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# define ASIO_SVC_T1 detail::deadline_timer_service<traits_helper>
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-// A separate base class is used to ensure that the io_service is initialised
-// prior to the basic_socket_streambuf's basic_socket base class.
-class socket_streambuf_base
+// A separate base class is used to ensure that the io_context member is
+// initialised prior to the basic_socket_streambuf's basic_socket base class.
+class socket_streambuf_io_context
+{
+protected:
+  socket_streambuf_io_context(io_context* ctx)
+    : default_io_context_(ctx)
+  {
+  }
+
+  shared_ptr<io_context> default_io_context_;
+};
+
+// A separate base class is used to ensure that the dynamically allocated
+// buffers are constructed prior to the basic_socket_streambuf's basic_socket
+// base class. This makes moving the socket is the last potentially throwing
+// step in the streambuf's move constructor, giving the constructor a strong
+// exception safety guarantee.
+class socket_streambuf_buffers
 {
 protected:
-  io_service io_service_;
+  socket_streambuf_buffers()
+    : get_buffer_(buffer_size),
+      put_buffer_(buffer_size)
+  {
+  }
+
+  enum { buffer_size = 512 };
+  std::vector<char> get_buffer_;
+  std::vector<char> put_buffer_;
 };
 
 } // namespace detail
 
+#if !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
+#define ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= stream_socket_service<Protocol>),
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+    typename Clock = boost::posix_time::ptime,
+    typename WaitTraits = time_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF2(= deadline_timer_service<Clock, WaitTraits>)>
+#else // defined(ASIO_HAS_BOOST_DATE_TIME)
+      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+    typename Clock = chrono::steady_clock,
+    typename WaitTraits = wait_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF1(= steady_timer::service_type)>
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+class basic_socket_streambuf;
+
+#endif // !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
+
 /// Iostream streambuf for a socket.
+#if defined(GENERATING_DOCUMENTATION)
 template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol>,
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  || defined(GENERATING_DOCUMENTATION)
-    typename Time = boost::posix_time::ptime,
-    typename TimeTraits = asio::time_traits<Time>,
-    typename TimerService = deadline_timer_service<Time, TimeTraits> >
-#else
-    typename Time = steady_timer::clock_type,
-    typename TimeTraits = steady_timer::traits_type,
-    typename TimerService = steady_timer::service_type>
-#endif
+    typename Clock = chrono::steady_clock,
+    typename WaitTraits = wait_traits<Clock> >
+#else // defined(GENERATING_DOCUMENTATION)
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Clock, typename WaitTraits ASIO_SVC_TPARAM1>
+#endif // defined(GENERATING_DOCUMENTATION)
 class basic_socket_streambuf
   : public std::streambuf,
-    private detail::socket_streambuf_base,
-    public basic_socket<Protocol, StreamSocketService>
+    private detail::socket_streambuf_io_context,
+    private detail::socket_streambuf_buffers,
+#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+    private basic_socket<Protocol ASIO_SVC_TARG>
+#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+    public basic_socket<Protocol ASIO_SVC_TARG>
+#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
 {
 private:
   // These typedefs are intended keep this class's implementation independent
-  // of whether it's using Boost.DateTime, Boost.Chrono or std::chrono.
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-  typedef TimeTraits traits_helper;
-#else
-  typedef detail::chrono_time_traits<Time, TimeTraits> traits_helper;
-#endif
+  // of whether it's using Boost.DateClock, Boost.Chrono or std::chrono.
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+  typedef WaitTraits traits_helper;
+#else // defined(ASIO_HAS_BOOST_DATE_TIME)
+      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+  typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
 
 public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
+  /// The clock type.
+  typedef Clock clock_type;
+
 #if defined(GENERATING_DOCUMENTATION)
+  /// (Deprecated: Use time_point.) The time type.
+  typedef typename WaitTraits::time_type time_type;
+
   /// The time type.
-  typedef typename TimeTraits::time_type time_type;
+  typedef typename WaitTraits::time_point time_point;
+
+  /// (Deprecated: Use duration.) The duration type.
+  typedef typename WaitTraits::duration_type duration_type;
 
   /// The duration type.
-  typedef typename TimeTraits::duration_type duration_type;
+  typedef typename WaitTraits::duration duration;
 #else
+# if !defined(ASIO_NO_DEPRECATED)
   typedef typename traits_helper::time_type time_type;
   typedef typename traits_helper::duration_type duration_type;
+# endif // !defined(ASIO_NO_DEPRECATED)
+  typedef typename traits_helper::time_type time_point;
+  typedef typename traits_helper::duration_type duration;
 #endif
 
   /// Construct a basic_socket_streambuf without establishing a connection.
   basic_socket_streambuf()
-    : basic_socket<Protocol, StreamSocketService>(
-        this->detail::socket_streambuf_base::io_service_),
-      unbuffered_(false),
-      timer_service_(0),
-      timer_state_(no_timer)
+    : detail::socket_streambuf_io_context(new io_context),
+      basic_socket<Protocol ASIO_SVC_TARG>(*default_io_context_),
+      expiry_time_(max_expiry_time())
   {
     init_buffers();
   }
 
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Construct a basic_socket_streambuf from the supplied socket.
+  explicit basic_socket_streambuf(basic_stream_socket<protocol_type> s)
+    : detail::socket_streambuf_io_context(0),
+      basic_socket<Protocol ASIO_SVC_TARG>(std::move(s)),
+      expiry_time_(max_expiry_time())
+  {
+    init_buffers();
+  }
+
+  /// Move-construct a basic_socket_streambuf from another.
+  basic_socket_streambuf(basic_socket_streambuf&& other)
+    : detail::socket_streambuf_io_context(other),
+      basic_socket<Protocol ASIO_SVC_TARG>(std::move(other.socket())),
+      ec_(other.ec_),
+      expiry_time_(other.expiry_time_)
+  {
+    get_buffer_.swap(other.get_buffer_);
+    put_buffer_.swap(other.put_buffer_);
+    setg(other.eback(), other.gptr(), other.egptr());
+    setp(other.pptr(), other.epptr());
+    other.ec_ = asio::error_code();
+    other.expiry_time_ = max_expiry_time();
+    other.init_buffers();
+  }
+
+  /// Move-assign a basic_socket_streambuf from another.
+  basic_socket_streambuf& operator=(basic_socket_streambuf&& other)
+  {
+    this->close();
+    socket() = std::move(other.socket());
+    detail::socket_streambuf_io_context::operator=(other);
+    ec_ = other.ec_;
+    expiry_time_ = other.expiry_time_;
+    get_buffer_.swap(other.get_buffer_);
+    put_buffer_.swap(other.put_buffer_);
+    setg(other.eback(), other.gptr(), other.egptr());
+    setp(other.pptr(), other.epptr());
+    other.ec_ = asio::error_code();
+    other.expiry_time_ = max_expiry_time();
+    other.put_buffer_.resize(buffer_size);
+    other.init_buffers();
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destructor flushes buffered data.
   virtual ~basic_socket_streambuf()
   {
     if (pptr() != pbase())
       overflow(traits_type::eof());
-
-    destroy_timer();
   }
 
   /// Establish a connection.
@@ -154,29 +273,11 @@ class basic_socket_streambuf
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
    */
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* connect(
-      const endpoint_type& endpoint)
+  basic_socket_streambuf* connect(const endpoint_type& endpoint)
   {
     init_buffers();
-
-    this->basic_socket<Protocol, StreamSocketService>::close(ec_);
-
-    if (timer_state_ == timer_has_expired)
-    {
-      ec_ = asio::error::operation_aborted;
-      return 0;
-    }
-
-    io_handler handler = { this };
-    this->basic_socket<Protocol, StreamSocketService>::async_connect(
-        endpoint, handler);
-
-    ec_ = asio::error::would_block;
-    this->get_service().get_io_service().reset();
-    do this->get_service().get_io_service().run_one();
-    while (ec_ == asio::error::would_block);
-
+    ec_ = asio::error_code();
+    this->connect_to_endpoints(&endpoint, &endpoint + 1);
     return !ec_ ? this : 0;
   }
 
@@ -191,19 +292,15 @@ class basic_socket_streambuf
    * pointer otherwise.
    */
   template <typename T1, ..., typename TN>
-  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
-      T1 t1, ..., TN tn);
+  basic_socket_streambuf* connect(T1 t1, ..., TN tn);
 #elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
   template <typename... T>
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* connect(T... x)
+  basic_socket_streambuf* 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);
+    resolver_type resolver(socket().get_executor().context());
+    connect_to_endpoints(resolver.resolve(x..., ec_));
     return !ec_ ? this : 0;
   }
 #else
@@ -215,17 +312,34 @@ class basic_socket_streambuf
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
    */
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* close()
+  basic_socket_streambuf* close()
   {
     sync();
-    this->basic_socket<Protocol, StreamSocketService>::close(ec_);
+    socket().close(ec_);
     if (!ec_)
       init_buffers();
     return !ec_ ? this : 0;
   }
 
+  /// Get a reference to the underlying socket.
+  basic_socket<Protocol ASIO_SVC_TARG>& socket()
+  {
+    return *this;
+  }
+
   /// Get the last error associated with the stream buffer.
+  /**
+   * @return An \c error_code corresponding to the last error from the stream
+   * buffer.
+   */
+  const asio::error_code& error() const
+  {
+    return ec_;
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use error().) Get the last error associated with the stream
+  /// buffer.
   /**
    * @return An \c error_code corresponding to the last error from the stream
    * buffer.
@@ -235,16 +349,26 @@ class basic_socket_streambuf
     return error();
   }
 
+  /// (Deprecated: Use expiry().) Get the stream buffer's expiry time as an
+  /// absolute time.
+  /**
+   * @return An absolute time value representing the stream buffer's expiry
+   * time.
+   */
+  time_point expires_at() const
+  {
+    return expiry_time_;
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
   /// 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
+  time_point expiry() const
   {
-    return timer_service_
-      ? timer_service_->expires_at(timer_implementation_)
-      : time_type();
+    return expiry_time_;
   }
 
   /// Set the stream buffer's expiry time as an absolute time.
@@ -256,27 +380,38 @@ class basic_socket_streambuf
    *
    * @param expiry_time The expiry time to be used for the stream.
    */
-  void expires_at(const time_type& expiry_time)
+  void expires_at(const time_point& expiry_time)
   {
-    construct_timer();
-
-    asio::error_code ec;
-    timer_service_->expires_at(timer_implementation_, expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_at");
+    expiry_time_ = expiry_time;
+  }
 
-    start_timer();
+  /// 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
+   * asio::error::operation_aborted.
+   *
+   * @param expiry_time The expiry time to be used for the timer.
+   */
+  void expires_after(const duration& expiry_time)
+  {
+    expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
   }
 
-  /// Get the stream buffer's expiry time relative to now.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use expiry().) 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
+  duration expires_from_now() const
   {
     return traits_helper::subtract(expires_at(), traits_helper::now());
   }
 
-  /// Set the stream buffer's expiry time relative to now.
+  /// (Deprecated: Use expires_after().) 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
@@ -285,109 +420,126 @@ class basic_socket_streambuf
    *
    * @param expiry_time The expiry time to be used for the timer.
    */
-  void expires_from_now(const duration_type& expiry_time)
+  void expires_from_now(const duration& expiry_time)
   {
-    construct_timer();
-
-    asio::error_code ec;
-    timer_service_->expires_from_now(timer_implementation_, expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_from_now");
-
-    start_timer();
+    expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 protected:
   int_type underflow()
   {
-    if (gptr() == egptr())
+#if defined(ASIO_WINDOWS_RUNTIME)
+    ec_ = asio::error::operation_not_supported;
+    return traits_type::eof();
+#else // defined(ASIO_WINDOWS_RUNTIME)
+    if (gptr() != egptr())
+      return traits_type::eof();
+
+    for (;;)
     {
-      if (timer_state_ == timer_has_expired)
+      // Check if we are past the expiry time.
+      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
       {
-        ec_ = asio::error::operation_aborted;
+        ec_ = asio::error::timed_out;
         return traits_type::eof();
       }
 
-      io_handler handler = { this };
-      this->get_service().async_receive(this->get_implementation(),
-          asio::buffer(asio::buffer(get_buffer_) + putback_max),
-          0, handler);
+      // Try to complete the operation without blocking.
+      if (!socket().native_non_blocking())
+        socket().native_non_blocking(true, ec_);
+      detail::buffer_sequence_adapter<mutable_buffer, mutable_buffer>
+        bufs(asio::buffer(get_buffer_) + putback_max);
+      detail::signed_size_type bytes = detail::socket_ops::recv(
+          socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
 
-      ec_ = asio::error::would_block;
-      this->get_service().get_io_service().reset();
-      do this->get_service().get_io_service().run_one();
-      while (ec_ == asio::error::would_block);
-      if (ec_)
+      // Check if operation succeeded.
+      if (bytes > 0)
+      {
+        setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
+            &get_buffer_[0] + putback_max + bytes);
+        return traits_type::to_int_type(*gptr());
+      }
+
+      // Check for EOF.
+      if (bytes == 0)
+      {
+        ec_ = asio::error::eof;
+        return traits_type::eof();
+      }
+
+      // Operation failed.
+      if (ec_ != asio::error::would_block
+          && ec_ != asio::error::try_again)
         return traits_type::eof();
 
-      setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
-          &get_buffer_[0] + putback_max + bytes_transferred_);
-      return traits_type::to_int_type(*gptr());
-    }
-    else
-    {
-      return traits_type::eof();
+      // Wait for socket to become ready.
+      if (detail::socket_ops::poll_read(
+            socket().native_handle(), 0, timeout(), ec_) < 0)
+        return traits_type::eof();
     }
+#endif // defined(ASIO_WINDOWS_RUNTIME)
   }
 
   int_type overflow(int_type c)
   {
-    if (unbuffered_)
+#if defined(ASIO_WINDOWS_RUNTIME)
+    ec_ = asio::error::operation_not_supported;
+    return traits_type::eof();
+#else // defined(ASIO_WINDOWS_RUNTIME)
+    char_type ch = traits_type::to_char_type(c);
+
+    // Determine what needs to be sent.
+    const_buffer output_buffer;
+    if (put_buffer_.empty())
     {
       if (traits_type::eq_int_type(c, traits_type::eof()))
+        return traits_type::not_eof(c); // Nothing to do.
+      output_buffer = asio::buffer(&ch, sizeof(char_type));
+    }
+    else
+    {
+      output_buffer = asio::buffer(pbase(),
+          (pptr() - pbase()) * sizeof(char_type));
+    }
+
+    while (output_buffer.size() > 0)
+    {
+      // Check if we are past the expiry time.
+      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
       {
-        // Nothing to do.
-        return traits_type::not_eof(c);
+        ec_ = asio::error::timed_out;
+        return traits_type::eof();
       }
-      else
+
+      // Try to complete the operation without blocking.
+      if (!socket().native_non_blocking())
+        socket().native_non_blocking(true, ec_);
+      detail::buffer_sequence_adapter<
+        const_buffer, const_buffer> bufs(output_buffer);
+      detail::signed_size_type bytes = detail::socket_ops::send(
+          socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
+
+      // Check if operation succeeded.
+      if (bytes > 0)
       {
-        if (timer_state_ == timer_has_expired)
-        {
-          ec_ = asio::error::operation_aborted;
-          return traits_type::eof();
-        }
-
-        // Send the single character immediately.
-        char_type ch = traits_type::to_char_type(c);
-        io_handler handler = { this };
-        this->get_service().async_send(this->get_implementation(),
-            asio::buffer(&ch, sizeof(char_type)), 0, handler);
-
-        ec_ = asio::error::would_block;
-        this->get_service().get_io_service().reset();
-        do this->get_service().get_io_service().run_one();
-        while (ec_ == asio::error::would_block);
-        if (ec_)
-          return traits_type::eof();
-
-        return c;
+        output_buffer += static_cast<std::size_t>(bytes);
+        continue;
       }
+
+      // Operation failed.
+      if (ec_ != asio::error::would_block
+          && ec_ != asio::error::try_again)
+        return traits_type::eof();
+
+      // Wait for socket to become ready.
+      if (detail::socket_ops::poll_write(
+            socket().native_handle(), 0, timeout(), ec_) < 0)
+        return traits_type::eof();
     }
-    else
+
+    if (!put_buffer_.empty())
     {
-      // Send all data in the output buffer.
-      asio::const_buffer buffer =
-        asio::buffer(pbase(), pptr() - pbase());
-      while (asio::buffer_size(buffer) > 0)
-      {
-        if (timer_state_ == timer_has_expired)
-        {
-          ec_ = asio::error::operation_aborted;
-          return traits_type::eof();
-        }
-
-        io_handler handler = { this };
-        this->get_service().async_send(this->get_implementation(),
-            asio::buffer(buffer), 0, handler);
-
-        ec_ = asio::error::would_block;
-        this->get_service().get_io_service().reset();
-        do this->get_service().get_io_service().run_one();
-        while (ec_ == asio::error::would_block);
-        if (ec_)
-          return traits_type::eof();
-
-        buffer = buffer + bytes_transferred_;
-      }
       setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
 
       // If the new character is eof then our work here is done.
@@ -395,10 +547,12 @@ class basic_socket_streambuf
         return traits_type::not_eof(c);
 
       // Add the new character to the output buffer.
-      *pptr() = traits_type::to_char_type(c);
+      *pptr() = ch;
       pbump(1);
-      return c;
     }
+
+    return c;
+#endif // defined(ASIO_WINDOWS_RUNTIME)
   }
 
   int sync()
@@ -410,154 +564,140 @@ class basic_socket_streambuf
   {
     if (pptr() == pbase() && s == 0 && n == 0)
     {
-      unbuffered_ = true;
+      put_buffer_.clear();
       setp(0, 0);
+      sync();
       return this;
     }
 
     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 asio::error_code& error() const
-  {
-    return ec_;
-  }
-
 private:
+  // Disallow copying and assignment.
+  basic_socket_streambuf(const basic_socket_streambuf&) ASIO_DELETED;
+  basic_socket_streambuf& operator=(
+      const basic_socket_streambuf&) ASIO_DELETED;
+
   void init_buffers()
   {
     setg(&get_buffer_[0],
         &get_buffer_[0] + putback_max,
         &get_buffer_[0] + putback_max);
-    if (unbuffered_)
+
+    if (put_buffer_.empty())
       setp(0, 0);
     else
       setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
   }
 
-  template <typename ResolverQuery>
-  void resolve_and_connect(const ResolverQuery& query)
+  int timeout() const
   {
-    typedef typename Protocol::resolver resolver_type;
-    typedef typename resolver_type::iterator iterator_type;
-    resolver_type resolver(detail::socket_streambuf_base::io_service_);
-    iterator_type i = resolver.resolve(query, ec_);
-    if (!ec_)
-    {
-      iterator_type end;
-      ec_ = asio::error::host_not_found;
-      while (ec_ && i != end)
-      {
-        this->basic_socket<Protocol, StreamSocketService>::close(ec_);
-
-        if (timer_state_ == timer_has_expired)
-        {
-          ec_ = asio::error::operation_aborted;
-          return;
-        }
-
-        io_handler handler = { this };
-        this->basic_socket<Protocol, StreamSocketService>::async_connect(
-            *i, handler);
-
-        ec_ = asio::error::would_block;
-        this->get_service().get_io_service().reset();
-        do this->get_service().get_io_service().run_one();
-        while (ec_ == asio::error::would_block);
-
-        ++i;
-      }
-    }
+    int64_t msec = traits_helper::to_posix_duration(
+        traits_helper::subtract(expiry_time_,
+          traits_helper::now())).total_milliseconds();
+    if (msec > (std::numeric_limits<int>::max)())
+      msec = (std::numeric_limits<int>::max)();
+    else if (msec < 0)
+      msec = 0;
+    return static_cast<int>(msec);
   }
 
-  struct io_handler;
-  friend struct io_handler;
-  struct io_handler
+  template <typename EndpointSequence>
+  void connect_to_endpoints(const EndpointSequence& endpoints)
   {
-    basic_socket_streambuf* this_;
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred = 0)
-    {
-      this_->ec_ = ec;
-      this_->bytes_transferred_ = bytes_transferred;
-    }
-  };
+    this->connect_to_endpoints(endpoints.begin(), endpoints.end());
+  }
 
-  struct timer_handler;
-  friend struct timer_handler;
-  struct timer_handler
+  template <typename EndpointIterator>
+  void connect_to_endpoints(EndpointIterator begin, EndpointIterator end)
   {
-    basic_socket_streambuf* this_;
-
-    void operator()(const asio::error_code&)
+#if defined(ASIO_WINDOWS_RUNTIME)
+    ec_ = asio::error::operation_not_supported;
+#else // defined(ASIO_WINDOWS_RUNTIME)
+    if (ec_)
+      return;
+
+    ec_ = asio::error::not_found;
+    for (EndpointIterator i = begin; i != end; ++i)
     {
-      time_type now = traits_helper::now();
-
-      time_type expiry_time = this_->timer_service_->expires_at(
-            this_->timer_implementation_);
-
-      if (traits_helper::less_than(now, expiry_time))
+      // Check if we are past the expiry time.
+      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
       {
-        this_->timer_state_ = timer_is_pending;
-        this_->timer_service_->async_wait(this_->timer_implementation_, *this);
+        ec_ = asio::error::timed_out;
+        return;
       }
-      else
-      {
-        this_->timer_state_ = timer_has_expired;
-        asio::error_code ec;
-        this_->basic_socket<Protocol, StreamSocketService>::close(ec);
-      }
-    }
-  };
 
-  void construct_timer()
-  {
-    if (timer_service_ == 0)
-    {
-      TimerService& timer_service = use_service<TimerService>(
-          detail::socket_streambuf_base::io_service_);
-      timer_service.construct(timer_implementation_);
-      timer_service_ = &timer_service;
+      // Close and reopen the socket.
+      typename Protocol::endpoint ep(*i);
+      socket().close(ec_);
+      socket().open(ep.protocol(), ec_);
+      if (ec_)
+        continue;
+
+      // Try to complete the operation without blocking.
+      if (!socket().native_non_blocking())
+        socket().native_non_blocking(true, ec_);
+      detail::socket_ops::connect(socket().native_handle(),
+          ep.data(), ep.size(), ec_);
+
+      // Check if operation succeeded.
+      if (!ec_)
+        return;
+
+      // Operation failed.
+      if (ec_ != asio::error::in_progress
+          && ec_ != asio::error::would_block)
+        continue;
+
+      // Wait for socket to become ready.
+      if (detail::socket_ops::poll_connect(
+            socket().native_handle(), timeout(), ec_) < 0)
+        continue;
+
+      // Get the error code from the connect operation.
+      int connect_error = 0;
+      size_t connect_error_len = sizeof(connect_error);
+      if (detail::socket_ops::getsockopt(socket().native_handle(), 0,
+            SOL_SOCKET, SO_ERROR, &connect_error, &connect_error_len, ec_)
+          == detail::socket_error_retval)
+        return;
+
+      // Check the result of the connect operation.
+      ec_ = asio::error_code(connect_error,
+          asio::error::get_system_category());
+      if (!ec_)
+        return;
     }
+#endif // defined(ASIO_WINDOWS_RUNTIME)
   }
 
-  void destroy_timer()
+  // Helper function to get the maximum expiry time.
+  static time_point max_expiry_time()
   {
-    if (timer_service_)
-      timer_service_->destroy(timer_implementation_);
-  }
-
-  void start_timer()
-  {
-    if (timer_state_ != timer_is_pending)
-    {
-      timer_handler handler = { this };
-      handler(asio::error_code());
-    }
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+    return boost::posix_time::pos_infin;
+#else // defined(ASIO_HAS_BOOST_DATE_TIME)
+      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
+    return (time_point::max)();
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
   }
 
   enum { putback_max = 8 };
-  enum { buffer_size = 512 };
-  asio::detail::array<char, buffer_size> get_buffer_;
-  asio::detail::array<char, buffer_size> put_buffer_;
-  bool unbuffered_;
   asio::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_;
+  time_point expiry_time_;
 };
 
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# undef ASIO_SVC_T1
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
 # undef ASIO_PRIVATE_CONNECT_DEF
 #endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
diff --git a/extern/include/asio/basic_stream_socket.hpp b/extern/include/asio/basic_stream_socket.hpp
index 16962ae4..eea88627 100644
--- a/extern/include/asio/basic_stream_socket.hpp
+++ b/extern/include/asio/basic_stream_socket.hpp
@@ -2,7 +2,7 @@
 // basic_stream_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,7 +22,10 @@
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
-#include "asio/stream_socket_service.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/stream_socket_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 #include "asio/detail/push_options.hpp"
 
@@ -40,18 +43,19 @@ namespace asio {
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
-template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol> >
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= stream_socket_service<Protocol>)>
 class basic_stream_socket
-  : public basic_socket<Protocol, StreamSocketService>
+  : public basic_socket<Protocol ASIO_SVC_TARG>
 {
 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_handle_type native_handle_type;
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_socket<
+    Protocol ASIO_SVC_TARG>::native_handle_type native_handle_type;
+#endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
@@ -65,11 +69,11 @@ class basic_stream_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 stream socket will use to
+   * @param io_context The io_context object that the stream socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    */
-  explicit basic_stream_socket(asio::io_service& io_service)
-    : basic_socket<Protocol, StreamSocketService>(io_service)
+  explicit basic_stream_socket(asio::io_context& io_context)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context)
   {
   }
 
@@ -78,16 +82,16 @@ class basic_stream_socket
    * This constructor creates and opens a stream 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 stream socket will use to
+   * @param io_context The io_context object that the stream 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 asio::system_error Thrown on failure.
    */
-  basic_stream_socket(asio::io_service& io_service,
+  basic_stream_socket(asio::io_context& io_context,
       const protocol_type& protocol)
-    : basic_socket<Protocol, StreamSocketService>(io_service, protocol)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, protocol)
   {
   }
 
@@ -98,7 +102,7 @@ class basic_stream_socket
    * 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 stream socket will use to
+   * @param io_context The io_context object that the stream 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 stream
@@ -106,9 +110,9 @@ class basic_stream_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_stream_socket(asio::io_service& io_service,
+  basic_stream_socket(asio::io_context& io_context,
       const endpoint_type& endpoint)
-    : basic_socket<Protocol, StreamSocketService>(io_service, endpoint)
+    : basic_socket<Protocol ASIO_SVC_TARG>(io_context, endpoint)
   {
   }
 
@@ -117,7 +121,7 @@ class basic_stream_socket
    * This constructor creates a stream socket object to hold an existing native
    * socket.
    *
-   * @param io_service The io_service object that the stream socket will use to
+   * @param io_context The io_context object that the stream socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
@@ -126,10 +130,10 @@ class basic_stream_socket
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_stream_socket(asio::io_service& io_service,
+  basic_stream_socket(asio::io_context& io_context,
       const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, StreamSocketService>(
-        io_service, protocol, native_socket)
+    : basic_socket<Protocol ASIO_SVC_TARG>(
+        io_context, protocol, native_socket)
   {
   }
 
@@ -142,11 +146,10 @@ class basic_stream_socket
    * 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.
+   * constructed using the @c basic_stream_socket(io_context&) constructor.
    */
   basic_stream_socket(basic_stream_socket&& other)
-    : basic_socket<Protocol, StreamSocketService>(
-        ASIO_MOVE_CAST(basic_stream_socket)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -158,12 +161,11 @@ class basic_stream_socket
    * 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.
+   * constructed using the @c basic_stream_socket(io_context&) constructor.
    */
   basic_stream_socket& operator=(basic_stream_socket&& other)
   {
-    basic_socket<Protocol, StreamSocketService>::operator=(
-        ASIO_MOVE_CAST(basic_stream_socket)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 
@@ -176,15 +178,13 @@ class basic_stream_socket
    * 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.
+   * constructed using the @c basic_stream_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename StreamSocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   basic_stream_socket(
-      basic_stream_socket<Protocol1, StreamSocketService1>&& other,
+      basic_stream_socket<Protocol1 ASIO_SVC_TARG1>&& other,
       typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
-    : basic_socket<Protocol, StreamSocketService>(
-        ASIO_MOVE_CAST2(basic_stream_socket<
-          Protocol1, StreamSocketService1>)(other))
+    : basic_socket<Protocol ASIO_SVC_TARG>(std::move(other))
   {
   }
 
@@ -196,20 +196,27 @@ class basic_stream_socket
    * 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.
+   * constructed using the @c basic_stream_socket(io_context&) constructor.
    */
-  template <typename Protocol1, typename StreamSocketService1>
+  template <typename Protocol1 ASIO_SVC_TPARAM1>
   typename enable_if<is_convertible<Protocol1, Protocol>::value,
       basic_stream_socket>::type& operator=(
-        basic_stream_socket<Protocol1, StreamSocketService1>&& other)
+        basic_stream_socket<Protocol1 ASIO_SVC_TARG1>&& other)
   {
-    basic_socket<Protocol, StreamSocketService>::operator=(
-        ASIO_MOVE_CAST2(basic_stream_socket<
-          Protocol1, StreamSocketService1>)(other));
+    basic_socket<Protocol ASIO_SVC_TARG>::operator=(std::move(other));
     return *this;
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
+  /// Destroys the socket.
+  /**
+   * This function destroys the socket, cancelling any outstanding asynchronous
+   * operations associated with the socket as if by calling @c cancel.
+   */
+  ~basic_stream_socket()
+  {
+  }
+
   /// Send some data on the socket.
   /**
    * This function is used to send data on the stream socket. The function
@@ -329,7 +336,7 @@ class basic_stream_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
@@ -354,9 +361,20 @@ class basic_stream_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(
         this->get_implementation(), buffers, 0,
         ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(
+        this->get_implementation(), buffers, 0,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous send.
@@ -381,7 +399,7 @@ class basic_stream_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
@@ -407,9 +425,20 @@ class basic_stream_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(
         this->get_implementation(), buffers, flags,
         ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(
+        this->get_implementation(), buffers, flags,
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Receive some data on the socket.
@@ -537,7 +566,7 @@ class basic_stream_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
@@ -564,8 +593,18 @@ class basic_stream_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Start an asynchronous receive.
@@ -590,7 +629,7 @@ class basic_stream_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
@@ -618,8 +657,18 @@ class basic_stream_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(this->get_implementation(),
         buffers, flags, ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, flags, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Write some data to the socket.
@@ -702,7 +751,7 @@ class basic_stream_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
@@ -727,8 +776,18 @@ class basic_stream_socket
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_send(this->get_implementation(),
         buffers, 0, ASIO_MOVE_CAST(WriteHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_send(this->get_implementation(),
+        buffers, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 
   /// Read some data from the socket.
@@ -814,7 +873,7 @@ class basic_stream_socket
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
@@ -840,8 +899,18 @@ class basic_stream_socket
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
     return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, ASIO_MOVE_CAST(ReadHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_receive(this->get_implementation(),
+        buffers, 0, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 };
 
diff --git a/extern/include/asio/basic_streambuf.hpp b/extern/include/asio/basic_streambuf.hpp
index 34aa8e40..14f85d22 100644
--- a/extern/include/asio/basic_streambuf.hpp
+++ b/extern/include/asio/basic_streambuf.hpp
@@ -2,7 +2,7 @@
 // basic_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -119,8 +119,8 @@ class basic_streambuf
   /// The type used to represent the output sequence as a list of buffers.
   typedef implementation_defined mutable_buffers_type;
 #else
-  typedef asio::const_buffers_1 const_buffers_type;
-  typedef asio::mutable_buffers_1 mutable_buffers_type;
+  typedef ASIO_CONST_BUFFER const_buffers_type;
+  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;
 #endif
 
   /// Construct a basic_streambuf object.
@@ -151,11 +151,11 @@ class basic_streambuf
    * while (i != bufs.end())
    * {
    *   const_buffer buf(*i++);
-   *   s += buffer_size(buf);
+   *   s += buf.size();
    * }
    * @endcode
    */
-  std::size_t size() const
+  std::size_t size() const ASIO_NOEXCEPT
   {
     return pptr() - gptr();
   }
@@ -165,11 +165,21 @@ class basic_streambuf
    * @returns The allowed maximum of the sum of the sizes of the input sequence
    * and output sequence.
    */
-  std::size_t max_size() const
+  std::size_t max_size() const ASIO_NOEXCEPT
   {
     return max_size_;
   }
 
+  /// Get the current capacity of the basic_streambuf.
+  /**
+   * @returns The current total capacity of the streambuf, i.e. for both the
+   * input sequence and output sequence.
+   */
+  std::size_t capacity() const ASIO_NOEXCEPT
+  {
+    return buffer_.capacity();
+  }
+
   /// Get a list of buffers that represents the input sequence.
   /**
    * @returns An object of type @c const_buffers_type that satisfies
@@ -179,7 +189,7 @@ class basic_streambuf
    * @note The returned object is invalidated by any @c basic_streambuf member
    * function that modifies the input sequence or output sequence.
    */
-  const_buffers_type data() const
+  const_buffers_type data() const ASIO_NOEXCEPT
   {
     return asio::buffer(asio::const_buffer(gptr(),
           (pptr() - gptr()) * sizeof(char_type)));
@@ -222,8 +232,7 @@ class basic_streambuf
    */
   void commit(std::size_t n)
   {
-    if (pptr() + n > epptr())
-      n = epptr() - pptr();
+    n = std::min<std::size_t>(n, epptr() - pptr());
     pbump(static_cast<int>(n));
     setg(eback(), gptr(), pptr());
   }
@@ -350,15 +359,89 @@ class basic_streambuf
   }
 };
 
-// Helper function to get the preferred size for reading data. Used for any
-// user-provided specialisations of basic_streambuf.
+/// Adapts basic_streambuf to the dynamic buffer sequence type requirements.
+#if defined(GENERATING_DOCUMENTATION)
+template <typename Allocator = std::allocator<char> >
+#else
 template <typename Allocator>
-inline std::size_t read_size_helper(
-    basic_streambuf<Allocator>& sb, std::size_t max_size)
+#endif
+class basic_streambuf_ref
 {
-  return std::min<std::size_t>(512,
-      std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
-}
+public:
+  /// The type used to represent the input sequence as a list of buffers.
+  typedef typename basic_streambuf<Allocator>::const_buffers_type
+    const_buffers_type;
+
+  /// The type used to represent the output sequence as a list of buffers.
+  typedef typename basic_streambuf<Allocator>::mutable_buffers_type
+    mutable_buffers_type;
+
+  /// Construct a basic_streambuf_ref for the given basic_streambuf object.
+  explicit basic_streambuf_ref(basic_streambuf<Allocator>& sb)
+    : sb_(sb)
+  {
+  }
+
+  /// Copy construct a basic_streambuf_ref.
+  basic_streambuf_ref(const basic_streambuf_ref& other) ASIO_NOEXCEPT
+    : sb_(other.sb_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move construct a basic_streambuf_ref.
+  basic_streambuf_ref(basic_streambuf_ref&& other) ASIO_NOEXCEPT
+    : sb_(other.sb_)
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Get the size of the input sequence.
+  std::size_t size() const ASIO_NOEXCEPT
+  {
+    return sb_.size();
+  }
+
+  /// Get the maximum size of the dynamic buffer.
+  std::size_t max_size() const ASIO_NOEXCEPT
+  {
+    return sb_.max_size();
+  }
+
+  /// Get the current capacity of the dynamic buffer.
+  std::size_t capacity() const ASIO_NOEXCEPT
+  {
+    return sb_.capacity();
+  }
+
+  /// Get a list of buffers that represents the input sequence.
+  const_buffers_type data() const ASIO_NOEXCEPT
+  {
+    return sb_.data();
+  }
+
+  /// Get a list of buffers that represents the output sequence, with the given
+  /// size.
+  mutable_buffers_type prepare(std::size_t n)
+  {
+    return sb_.prepare(n);
+  }
+
+  /// Move bytes from the output sequence to the input sequence.
+  void commit(std::size_t n)
+  {
+    return sb_.commit(n);
+  }
+
+  /// Remove characters from the input sequence.
+  void consume(std::size_t n)
+  {
+    return sb_.consume(n);
+  }
+
+private:
+  basic_streambuf<Allocator>& sb_;
+};
 
 } // namespace asio
 
diff --git a/extern/include/asio/basic_streambuf_fwd.hpp b/extern/include/asio/basic_streambuf_fwd.hpp
index c53576b9..ed54fe95 100644
--- a/extern/include/asio/basic_streambuf_fwd.hpp
+++ b/extern/include/asio/basic_streambuf_fwd.hpp
@@ -2,7 +2,7 @@
 // basic_streambuf_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -26,6 +26,9 @@ namespace asio {
 template <typename Allocator = std::allocator<char> >
 class basic_streambuf;
 
+template <typename Allocator = std::allocator<char> >
+class basic_streambuf_ref;
+
 } // namespace asio
 
 #endif // !defined(ASIO_NO_IOSTREAM)
diff --git a/extern/include/asio/basic_waitable_timer.hpp b/extern/include/asio/basic_waitable_timer.hpp
index 02c2e9a5..22b85a69 100644
--- a/extern/include/asio/basic_waitable_timer.hpp
+++ b/extern/include/asio/basic_waitable_timer.hpp
@@ -2,7 +2,7 @@
 // basic_waitable_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,12 +22,36 @@
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
 #include "asio/wait_traits.hpp"
-#include "asio/waitable_timer_service.hpp"
+
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/waitable_timer_service.hpp"
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/detail/chrono_time_traits.hpp"
+# include "asio/detail/deadline_timer_service.hpp"
+# define ASIO_SVC_T \
+    detail::deadline_timer_service< \
+      detail::chrono_time_traits<Clock, WaitTraits> >
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 
+#if !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
+#define ASIO_BASIC_WAITABLE_TIMER_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Clock,
+    typename WaitTraits = asio::wait_traits<Clock>
+    ASIO_SVC_TPARAM_DEF2(= waitable_timer_service<Clock, WaitTraits>)>
+class basic_waitable_timer;
+
+#endif // !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
+
 /// Provides waitable timer functionality.
 /**
  * The basic_waitable_timer class template provides the ability to perform a
@@ -51,10 +75,10 @@ namespace asio {
  * Performing a blocking wait (C++11):
  * @code
  * // Construct a timer without setting an expiry time.
- * asio::steady_timer timer(io_service);
+ * asio::steady_timer timer(io_context);
  *
  * // Set an expiry time relative to now.
- * timer.expires_from_now(std::chrono::seconds(5));
+ * timer.expires_after(std::chrono::seconds(5));
  *
  * // Wait for the timer to expire.
  * timer.wait();
@@ -74,7 +98,7 @@ namespace asio {
  * ...
  *
  * // Construct a timer with an absolute expiry time.
- * asio::steady_timer timer(io_service,
+ * asio::steady_timer timer(io_context,
  *     std::chrono::steady_clock::now() + std::chrono::seconds(60));
  *
  * // Start an asynchronous wait.
@@ -91,7 +115,7 @@ namespace asio {
  * @code
  * void on_some_event()
  * {
- *   if (my_timer.expires_from_now(seconds(5)) > 0)
+ *   if (my_timer.expires_after(seconds(5)) > 0)
  *   {
  *     // We managed to cancel the timer. Start new asynchronous wait.
  *     my_timer.async_wait(on_timeout);
@@ -111,7 +135,7 @@ namespace asio {
  * }
  * @endcode
  *
- * @li The asio::basic_waitable_timer::expires_from_now() function
+ * @li The asio::basic_waitable_timer::expires_after() function
  * cancels any pending asynchronous waits, and returns the number of
  * asynchronous waits that were cancelled. If it returns 0 then you were too
  * late and the wait handler has already been executed, or will soon be
@@ -120,13 +144,14 @@ namespace asio {
  * @li If a wait handler is cancelled, the asio::error_code passed to
  * it contains the value asio::error::operation_aborted.
  */
-template <typename Clock,
-    typename WaitTraits = asio::wait_traits<Clock>,
-    typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits> >
+template <typename Clock, typename WaitTraits ASIO_SVC_TPARAM>
 class basic_waitable_timer
-  : public basic_io_object<WaitableTimerService>
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>
 {
 public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
   /// The clock type.
   typedef Clock clock_type;
 
@@ -142,14 +167,14 @@ class basic_waitable_timer
   /// Constructor.
   /**
    * This constructor creates a timer without setting an expiry time. The
-   * expires_at() or expires_from_now() functions must be called to set an
-   * expiry time before the timer can be waited on.
+   * expires_at() or expires_after() functions must be called to set an expiry
+   * time before the timer can be waited on.
    *
-   * @param io_service The io_service object that the timer will use to dispatch
+   * @param io_context The io_context object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    */
-  explicit basic_waitable_timer(asio::io_service& io_service)
-    : basic_io_object<WaitableTimerService>(io_service)
+  explicit basic_waitable_timer(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
   }
 
@@ -157,18 +182,18 @@ class basic_waitable_timer
   /**
    * This constructor creates a timer and sets the expiry time.
    *
-   * @param io_service The io_service object that the timer will use to dispatch
+   * @param io_context The io_context object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    *
    * @param expiry_time The expiry time to be used for the timer, expressed
    * as an absolute time.
    */
-  basic_waitable_timer(asio::io_service& io_service,
+  basic_waitable_timer(asio::io_context& io_context,
       const time_point& expiry_time)
-    : basic_io_object<WaitableTimerService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
-    this->service.expires_at(this->implementation, expiry_time, ec);
+    this->get_service().expires_at(this->get_implementation(), expiry_time, ec);
     asio::detail::throw_error(ec, "expires_at");
   }
 
@@ -176,21 +201,105 @@ class basic_waitable_timer
   /**
    * This constructor creates a timer and sets the expiry time.
    *
-   * @param io_service The io_service object that the timer will use to dispatch
+   * @param io_context The io_context object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    *
    * @param expiry_time The expiry time to be used for the timer, relative to
    * now.
    */
-  basic_waitable_timer(asio::io_service& io_service,
+  basic_waitable_timer(asio::io_context& io_context,
       const duration& expiry_time)
-    : basic_io_object<WaitableTimerService>(io_service)
+    : basic_io_object<ASIO_SVC_T>(io_context)
   {
     asio::error_code ec;
-    this->service.expires_from_now(this->implementation, expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_from_now");
+    this->get_service().expires_after(
+        this->get_implementation(), expiry_time, ec);
+    asio::detail::throw_error(ec, "expires_after");
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_waitable_timer from another.
+  /**
+   * This constructor moves a timer from one object to another.
+   *
+   * @param other The other basic_waitable_timer 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_waitable_timer(io_context&) constructor.
+   */
+  basic_waitable_timer(basic_waitable_timer&& other)
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_waitable_timer from another.
+  /**
+   * This assignment operator moves a timer from one object to another. Cancels
+   * any outstanding asynchronous operations associated with the target object.
+   *
+   * @param other The other basic_waitable_timer 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_waitable_timer(io_context&) constructor.
+   */
+  basic_waitable_timer& operator=(basic_waitable_timer&& other)
+  {
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the timer.
+  /**
+   * This function destroys the timer, cancelling any outstanding asynchronous
+   * wait operations associated with the timer as if by calling @c cancel.
+   */
+  ~basic_waitable_timer()
+  {
+  }
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+  // These functions are provided by basic_io_object<>.
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
   }
 
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
   /// Cancel any asynchronous operations that are waiting on the timer.
   /**
    * This function forces the completion of any pending asynchronous wait
@@ -216,12 +325,14 @@ class basic_waitable_timer
   std::size_t cancel()
   {
     asio::error_code ec;
-    std::size_t s = this->service.cancel(this->implementation, ec);
+    std::size_t s = this->get_service().cancel(this->get_implementation(), ec);
     asio::detail::throw_error(ec, "cancel");
     return s;
   }
 
-  /// Cancel any asynchronous operations that are waiting on the timer.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use non-error_code overload.) Cancel any asynchronous
+  /// operations that are waiting on the timer.
   /**
    * This function forces the completion of any pending asynchronous wait
    * operations against the timer. The handler for each cancelled operation will
@@ -245,8 +356,9 @@ class basic_waitable_timer
    */
   std::size_t cancel(asio::error_code& ec)
   {
-    return this->service.cancel(this->implementation, ec);
+    return this->get_service().cancel(this->get_implementation(), ec);
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Cancels one asynchronous operation that is waiting on the timer.
   /**
@@ -275,12 +387,15 @@ class basic_waitable_timer
   std::size_t cancel_one()
   {
     asio::error_code ec;
-    std::size_t s = this->service.cancel_one(this->implementation, ec);
+    std::size_t s = this->get_service().cancel_one(
+        this->get_implementation(), ec);
     asio::detail::throw_error(ec, "cancel_one");
     return s;
   }
 
-  /// Cancels one asynchronous operation that is waiting on the timer.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use non-error_code overload.) 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
@@ -306,17 +421,29 @@ class basic_waitable_timer
    */
   std::size_t cancel_one(asio::error_code& ec)
   {
-    return this->service.cancel_one(this->implementation, ec);
+    return this->get_service().cancel_one(this->get_implementation(), ec);
   }
 
-  /// Get the timer's expiry time as an absolute time.
+  /// (Deprecated: Use expiry().) Get the timer's expiry time as an absolute
+  /// time.
   /**
    * This function may be used to obtain the timer's current expiry time.
    * Whether the timer has expired or not does not affect this value.
    */
   time_point expires_at() const
   {
-    return this->service.expires_at(this->implementation);
+    return this->get_service().expires_at(this->get_implementation());
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the timer's expiry time as an absolute time.
+  /**
+   * This function may be used to obtain the timer's current expiry time.
+   * Whether the timer has expired or not does not affect this value.
+   */
+  time_point expiry() const
+  {
+    return this->get_service().expiry(this->get_implementation());
   }
 
   /// Set the timer's expiry time as an absolute time.
@@ -344,13 +471,15 @@ class basic_waitable_timer
   std::size_t expires_at(const time_point& expiry_time)
   {
     asio::error_code ec;
-    std::size_t s = this->service.expires_at(
-        this->implementation, expiry_time, ec);
+    std::size_t s = this->get_service().expires_at(
+        this->get_implementation(), expiry_time, ec);
     asio::detail::throw_error(ec, "expires_at");
     return s;
   }
 
-  /// Set the timer's expiry time as an absolute time.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use non-error_code overload.) Set the timer's expiry time as
+  /// an absolute time.
   /**
    * This function sets the expiry time. Any pending asynchronous wait
    * operations will be cancelled. The handler for each cancelled operation will
@@ -375,20 +504,55 @@ class basic_waitable_timer
   std::size_t expires_at(const time_point& expiry_time,
       asio::error_code& ec)
   {
-    return this->service.expires_at(this->implementation, expiry_time, ec);
+    return this->get_service().expires_at(
+        this->get_implementation(), expiry_time, ec);
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
-  /// Get the timer's expiry time relative to now.
+  /// Set the timer's expiry time relative to now.
+  /**
+   * This function sets the expiry time. Any pending asynchronous wait
+   * operations will be cancelled. The handler for each cancelled operation will
+   * be invoked with the asio::error::operation_aborted error code.
+   *
+   * @param expiry_time The expiry time to be used for the timer.
+   *
+   * @return The number of asynchronous operations that were cancelled.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note If the timer has already expired when expires_after() 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 expires_after(const duration& expiry_time)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().expires_after(
+        this->get_implementation(), expiry_time, ec);
+    asio::detail::throw_error(ec, "expires_after");
+    return s;
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use expiry().) Get the timer's expiry time relative to now.
   /**
    * This function may be used to obtain the timer's current expiry time.
    * Whether the timer has expired or not does not affect this value.
    */
   duration expires_from_now() const
   {
-    return this->service.expires_from_now(this->implementation);
+    return this->get_service().expires_from_now(this->get_implementation());
   }
 
-  /// Set the timer's expiry time relative to now.
+  /// (Deprecated: Use expires_after().) Set the timer's expiry time relative
+  /// to now.
   /**
    * This function sets the expiry time. Any pending asynchronous wait
    * operations will be cancelled. The handler for each cancelled operation will
@@ -413,13 +577,14 @@ class basic_waitable_timer
   std::size_t expires_from_now(const duration& expiry_time)
   {
     asio::error_code ec;
-    std::size_t s = this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
+    std::size_t s = this->get_service().expires_from_now(
+        this->get_implementation(), expiry_time, ec);
     asio::detail::throw_error(ec, "expires_from_now");
     return s;
   }
 
-  /// Set the timer's expiry time relative to now.
+  /// (Deprecated: Use expires_after().) Set the timer's expiry time relative
+  /// to now.
   /**
    * This function sets the expiry time. Any pending asynchronous wait
    * operations will be cancelled. The handler for each cancelled operation will
@@ -444,9 +609,10 @@ class basic_waitable_timer
   std::size_t expires_from_now(const duration& expiry_time,
       asio::error_code& ec)
   {
-    return this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
+    return this->get_service().expires_from_now(
+        this->get_implementation(), expiry_time, ec);
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Perform a blocking wait on the timer.
   /**
@@ -458,7 +624,7 @@ class basic_waitable_timer
   void wait()
   {
     asio::error_code ec;
-    this->service.wait(this->implementation, ec);
+    this->get_service().wait(this->get_implementation(), ec);
     asio::detail::throw_error(ec, "wait");
   }
 
@@ -471,7 +637,7 @@ class basic_waitable_timer
    */
   void wait(asio::error_code& ec)
   {
-    this->service.wait(this->implementation, ec);
+    this->get_service().wait(this->get_implementation(), ec);
   }
 
   /// Start an asynchronous wait on the timer.
@@ -496,7 +662,7 @@ class basic_waitable_timer
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename WaitHandler>
   ASIO_INITFN_RESULT_TYPE(WaitHandler,
@@ -507,13 +673,33 @@ class basic_waitable_timer
     // not meet the documented type requirements for a WaitHandler.
     ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
 
-    return this->service.async_wait(this->implementation,
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_wait(this->get_implementation(),
         ASIO_MOVE_CAST(WaitHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_wait(this->get_implementation(),
+        init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
+
+private:
+  // Disallow copying and assignment.
+  basic_waitable_timer(const basic_waitable_timer&) ASIO_DELETED;
+  basic_waitable_timer& operator=(
+      const basic_waitable_timer&) ASIO_DELETED;
 };
 
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# undef ASIO_SVC_T
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_BASIC_WAITABLE_TIMER_HPP
diff --git a/extern/include/asio/bind_executor.hpp b/extern/include/asio/bind_executor.hpp
new file mode 100644
index 00000000..9e2094b5
--- /dev/null
+++ b/extern/include/asio/bind_executor.hpp
@@ -0,0 +1,611 @@
+//
+// bind_executor.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_BIND_EXECUTOR_HPP
+#define ASIO_BIND_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/detail/variadic_templates.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/async_result.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/is_executor.hpp"
+#include "asio/uses_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+struct executor_binder_check
+{
+  typedef void type;
+};
+
+// Helper to automatically define nested typedef result_type.
+
+template <typename T, typename = void>
+struct executor_binder_result_type
+{
+protected:
+  typedef void result_type_or_void;
+};
+
+template <typename T>
+struct executor_binder_result_type<T,
+  typename executor_binder_check<typename T::result_type>::type>
+{
+  typedef typename T::result_type result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct executor_binder_result_type<R(*)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct executor_binder_result_type<R(&)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct executor_binder_result_type<R(*)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct executor_binder_result_type<R(&)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct executor_binder_result_type<R(*)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct executor_binder_result_type<R(&)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+// Helper to automatically define nested typedef argument_type.
+
+template <typename T, typename = void>
+struct executor_binder_argument_type {};
+
+template <typename T>
+struct executor_binder_argument_type<T,
+  typename executor_binder_check<typename T::argument_type>::type>
+{
+  typedef typename T::argument_type argument_type;
+};
+
+template <typename R, typename A1>
+struct executor_binder_argument_type<R(*)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+template <typename R, typename A1>
+struct executor_binder_argument_type<R(&)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+// Helper to automatically define nested typedefs first_argument_type and
+// second_argument_type.
+
+template <typename T, typename = void>
+struct executor_binder_argument_types {};
+
+template <typename T>
+struct executor_binder_argument_types<T,
+  typename executor_binder_check<typename T::first_argument_type>::type>
+{
+  typedef typename T::first_argument_type first_argument_type;
+  typedef typename T::second_argument_type second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct executor_binder_argument_type<R(*)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct executor_binder_argument_type<R(&)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+// Helper to:
+// - Apply the empty base optimisation to the executor.
+// - Perform uses_executor construction of the target type, if required.
+
+template <typename T, typename Executor, bool UsesExecutor>
+class executor_binder_base;
+
+template <typename T, typename Executor>
+class executor_binder_base<T, Executor, true>
+  : protected Executor
+{
+protected:
+  template <typename E, typename U>
+  executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
+    : executor_(ASIO_MOVE_CAST(E)(e)),
+      target_(executor_arg_t(), executor_, ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  Executor executor_;
+  T target_;
+};
+
+template <typename T, typename Executor>
+class executor_binder_base<T, Executor, false>
+{
+protected:
+  template <typename E, typename U>
+  executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
+    : executor_(ASIO_MOVE_CAST(E)(e)),
+      target_(ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  Executor executor_;
+  T target_;
+};
+
+// Helper to enable SFINAE on zero-argument operator() below.
+
+template <typename T, typename = void>
+struct executor_binder_result_of0
+{
+  typedef void type;
+};
+
+template <typename T>
+struct executor_binder_result_of0<T,
+  typename executor_binder_check<typename result_of<T()>::type>::type>
+{
+  typedef typename result_of<T()>::type type;
+};
+
+} // namespace detail
+
+/// A call wrapper type to bind an executor of type @c Executor to an object of
+/// type @c T.
+template <typename T, typename Executor>
+class executor_binder
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::executor_binder_result_type<T>,
+    public detail::executor_binder_argument_type<T>,
+    public detail::executor_binder_argument_types<T>,
+    private detail::executor_binder_base<
+      T, Executor, uses_executor<T, Executor>::value>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+public:
+  /// The type of the target object.
+  typedef T target_type;
+
+  /// The type of the associated executor.
+  typedef Executor executor_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The return type if a function.
+  /**
+   * The type of @c result_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to function type, @c result_type is a synonym for
+   * the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c result_type, then @c
+   * result_type is a synonym for @c T::result_type;
+   *
+   * @li otherwise @c result_type is not defined.
+   */
+  typedef see_below result_type;
+
+  /// The type of the function's argument.
+  /**
+   * The type of @c argument_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to a function type accepting a single argument,
+   * @c argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c argument_type, then @c
+   * argument_type is a synonym for @c T::argument_type;
+   *
+   * @li otherwise @c argument_type is not defined.
+   */
+  typedef see_below argument_type;
+
+  /// The type of the function's first argument.
+  /**
+   * The type of @c first_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * first_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c first_argument_type is a synonym for @c T::first_argument_type;
+   *
+   * @li otherwise @c first_argument_type is not defined.
+   */
+  typedef see_below first_argument_type;
+
+  /// The type of the function's second argument.
+  /**
+   * The type of @c second_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * second_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c second_argument_type is a synonym for @c T::second_argument_type;
+   *
+   * @li otherwise @c second_argument_type is not defined.
+   */
+  typedef see_below second_argument_type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct an executor wrapper for the specified object.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U>
+  executor_binder(executor_arg_t, const executor_type& e,
+      ASIO_MOVE_ARG(U) u)
+    : base_type(e, ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  /// Copy constructor.
+  executor_binder(const executor_binder& other)
+    : base_type(other.get_executor(), other.get())
+  {
+  }
+
+  /// Construct a copy, but specify a different executor.
+  executor_binder(executor_arg_t, const executor_type& e,
+      const executor_binder& other)
+    : base_type(e, other.get())
+  {
+  }
+
+  /// Construct a copy of a different executor wrapper type.
+  /**
+   * This constructor is only valid if the @c Executor type is constructible
+   * from type @c OtherExecutor, and the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U, typename OtherExecutor>
+  executor_binder(const executor_binder<U, OtherExecutor>& other)
+    : base_type(other.get_executor(), other.get())
+  {
+  }
+
+  /// Construct a copy of a different executor wrapper type, but specify a
+  /// different executor.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U, typename OtherExecutor>
+  executor_binder(executor_arg_t, const executor_type& e,
+      const executor_binder<U, OtherExecutor>& other)
+    : base_type(e, other.get())
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Move constructor.
+  executor_binder(executor_binder&& other)
+    : base_type(ASIO_MOVE_CAST(executor_type)(other.get_executor()),
+        ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct the target object, but specify a different executor.
+  executor_binder(executor_arg_t, const executor_type& e,
+      executor_binder&& other)
+    : base_type(e, ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct from a different executor wrapper type.
+  template <typename U, typename OtherExecutor>
+  executor_binder(executor_binder<U, OtherExecutor>&& other)
+    : base_type(ASIO_MOVE_CAST(OtherExecutor)(other.get_executor()),
+        ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+  /// Move construct from a different executor wrapper type, but specify a
+  /// different executor.
+  template <typename U, typename OtherExecutor>
+  executor_binder(executor_arg_t, const executor_type& e,
+      executor_binder<U, OtherExecutor>&& other)
+    : base_type(e, ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~executor_binder()
+  {
+  }
+
+  /// Obtain a reference to the target object.
+  target_type& get() ASIO_NOEXCEPT
+  {
+    return this->target_;
+  }
+
+  /// Obtain a reference to the target object.
+  const target_type& get() const ASIO_NOEXCEPT
+  {
+    return this->target_;
+  }
+
+  /// Obtain the associated executor.
+  executor_type get_executor() const ASIO_NOEXCEPT
+  {
+    return this->executor_;
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  template <typename... Args> auto operator()(Args&& ...);
+  template <typename... Args> auto operator()(Args&& ...) const;
+
+#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      ASIO_MOVE_ARG(Args)... args)
+  {
+    return this->target_(ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      ASIO_MOVE_ARG(Args)... args) const
+  {
+    return this->target_(ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#elif defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typename detail::executor_binder_result_of0<T>::type operator()()
+  {
+    return this->target_();
+  }
+
+  typename detail::executor_binder_result_of0<T>::type operator()() const
+  {
+    return this->target_();
+  }
+
+#define ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF(n) \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF)
+#undef ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF
+
+#else // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typedef typename detail::executor_binder_result_type<T>::result_type_or_void
+    result_type_or_void;
+
+  result_type_or_void operator()()
+  {
+    return this->target_();
+  }
+
+  result_type_or_void operator()() const
+  {
+    return this->target_();
+  }
+
+#define ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF(n) \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF)
+#undef ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF
+
+#endif // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+private:
+  typedef detail::executor_binder_base<T, Executor,
+    uses_executor<T, Executor>::value> base_type;
+};
+
+/// Associate an object of type @c T with an executor of type @c Executor.
+template <typename Executor, typename T>
+inline executor_binder<typename decay<T>::type, Executor>
+bind_executor(const Executor& ex, ASIO_MOVE_ARG(T) t,
+    typename enable_if<is_executor<Executor>::value>::type* = 0)
+{
+  return executor_binder<typename decay<T>::type, Executor>(
+      executor_arg_t(), ex, ASIO_MOVE_CAST(T)(t));
+}
+
+/// Associate an object of type @c T with an execution context's executor.
+template <typename ExecutionContext, typename T>
+inline executor_binder<typename decay<T>::type,
+  typename ExecutionContext::executor_type>
+bind_executor(ExecutionContext& ctx, ASIO_MOVE_ARG(T) t,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type* = 0)
+{
+  return executor_binder<typename decay<T>::type,
+    typename ExecutionContext::executor_type>(
+      executor_arg_t(), ctx.get_executor(), ASIO_MOVE_CAST(T)(t));
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename T, typename Executor>
+struct uses_executor<executor_binder<T, Executor>, Executor>
+  : true_type {};
+
+template <typename T, typename Executor, typename Signature>
+class async_result<executor_binder<T, Executor>, Signature>
+{
+public:
+  typedef executor_binder<
+    typename async_result<T, Signature>::completion_handler_type, Executor>
+      completion_handler_type;
+
+  typedef typename async_result<T, Signature>::return_type return_type;
+
+  explicit async_result(executor_binder<T, Executor>& b)
+    : target_(b.get())
+  {
+  }
+
+  return_type get()
+  {
+    return target_.get();
+  }
+
+private:
+  async_result(const async_result&) ASIO_DELETED;
+  async_result& operator=(const async_result&) ASIO_DELETED;
+
+  async_result<T, Signature> target_;
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+template <typename T, typename Executor, typename Signature>
+struct handler_type<executor_binder<T, Executor>, Signature>
+{
+  typedef executor_binder<
+    typename handler_type<T, Signature>::type, Executor> type;
+};
+
+template <typename T, typename Executor>
+class async_result<executor_binder<T, Executor> >
+{
+public:
+  typedef typename async_result<T>::type type;
+
+  explicit async_result(executor_binder<T, Executor>& b)
+    : target_(b.get())
+  {
+  }
+
+  type get()
+  {
+    return target_.get();
+  }
+
+private:
+  async_result<T> target_;
+};
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+template <typename T, typename Executor, typename Allocator>
+struct associated_allocator<executor_binder<T, Executor>, Allocator>
+{
+  typedef typename associated_allocator<T, Allocator>::type type;
+
+  static type get(const executor_binder<T, Executor>& b,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<T, Allocator>::get(b.get(), a);
+  }
+};
+
+template <typename T, typename Executor, typename Executor1>
+struct associated_executor<executor_binder<T, Executor>, Executor1>
+{
+  typedef Executor type;
+
+  static type get(const executor_binder<T, Executor>& b,
+      const Executor1& = Executor1()) ASIO_NOEXCEPT
+  {
+    return b.get_executor();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_BIND_EXECUTOR_HPP
diff --git a/extern/include/asio/buffer.hpp b/extern/include/asio/buffer.hpp
index 238722fa..a9aa8aad 100644
--- a/extern/include/asio/buffer.hpp
+++ b/extern/include/asio/buffer.hpp
@@ -2,7 +2,7 @@
 // buffer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,17 +18,23 @@
 #include "asio/detail/config.hpp"
 #include <cstddef>
 #include <cstring>
+#include <limits>
+#include <stdexcept>
 #include <string>
 #include <vector>
 #include "asio/detail/array_fwd.hpp"
+#include "asio/detail/is_buffer_sequence.hpp"
+#include "asio/detail/string_view.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/detail/type_traits.hpp"
 
-#if defined(ASIO_MSVC)
+#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1700)
 # if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)
 #  if !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
 #   define ASIO_ENABLE_BUFFER_DEBUGGING
 #  endif // !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
 # endif // defined(_HAS_ITERATOR_DEBUGGING)
-#endif // defined(ASIO_MSVC)
+#endif // defined(ASIO_MSVC) && (ASIO_MSVC >= 1700)
 
 #if defined(__GNUC__)
 # if defined(_GLIBCXX_DEBUG)
@@ -39,7 +45,7 @@
 #endif // defined(__GNUC__)
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-# include "asio/detail/function.hpp"
+# include "asio/detail/functional.hpp"
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
 
 #if defined(ASIO_HAS_BOOST_WORKAROUND)
@@ -62,13 +68,6 @@ namespace asio {
 class mutable_buffer;
 class const_buffer;
 
-namespace detail {
-void* buffer_cast_helper(const mutable_buffer&);
-const void* buffer_cast_helper(const const_buffer&);
-std::size_t buffer_size_helper(const mutable_buffer&);
-std::size_t buffer_size_helper(const const_buffer&);
-} // namespace detail
-
 /// Holds a buffer that can be modified.
 /**
  * The mutable_buffer class provides a safe representation of a buffer that can
@@ -77,29 +76,29 @@ std::size_t buffer_size_helper(const const_buffer&);
  *
  * @par Accessing Buffer Contents
  *
- * The contents of a buffer may be accessed using the @ref buffer_size
- * and @ref buffer_cast functions:
+ * The contents of a buffer may be accessed using the @c data() and @c size()
+ * member functions:
  *
  * @code asio::mutable_buffer b1 = ...;
- * std::size_t s1 = asio::buffer_size(b1);
- * unsigned char* p1 = asio::buffer_cast<unsigned char*>(b1);
+ * std::size_t s1 = b1.size();
+ * unsigned char* p1 = static_cast<unsigned char*>(b1.data());
  * @endcode
  *
- * The asio::buffer_cast function permits violations of type safety, so
- * uses of it in application code should be carefully considered.
+ * The @c data() member function permits violations of type safety, so uses of
+ * it in application code should be carefully considered.
  */
 class mutable_buffer
 {
 public:
   /// Construct an empty buffer.
-  mutable_buffer()
+  mutable_buffer() ASIO_NOEXCEPT
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
-  mutable_buffer(void* data, std::size_t size)
+  mutable_buffer(void* data, std::size_t size) ASIO_NOEXCEPT
     : data_(data),
       size_(size)
   {
@@ -120,12 +119,32 @@ class mutable_buffer
   }
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
 
-private:
-  friend void* asio::detail::buffer_cast_helper(
-      const mutable_buffer& b);
-  friend std::size_t asio::detail::buffer_size_helper(
-      const mutable_buffer& b);
+  /// Get a pointer to the beginning of the memory range.
+  void* data() const ASIO_NOEXCEPT
+  {
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+    if (size_ && debug_check_)
+      debug_check_();
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+    return data_;
+  }
+
+  /// Get the size of the memory range.
+  std::size_t size() const ASIO_NOEXCEPT
+  {
+    return size_;
+  }
+
+  /// Move the start of the buffer by the specified number of bytes.
+  mutable_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
+  {
+    std::size_t offset = n < size_ ? n : size_;
+    data_ = static_cast<char*>(data_) + offset;
+    size_ -= offset;
+    return *this;
+  }
 
+private:
   void* data_;
   std::size_t size_;
 
@@ -134,26 +153,10 @@ class mutable_buffer
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
-namespace detail {
-
-inline void* buffer_cast_helper(const mutable_buffer& b)
-{
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  if (b.size_ && b.debug_check_)
-    b.debug_check_();
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-  return b.data_;
-}
-
-inline std::size_t buffer_size_helper(const mutable_buffer& b)
-{
-  return b.size_;
-}
-
-} // namespace detail
+#if !defined(ASIO_NO_DEPRECATED)
 
-/// Adapts a single modifiable buffer so that it meets the requirements of the
-/// MutableBufferSequence concept.
+/// (Deprecated: Use mutable_buffer.) Adapts a single modifiable buffer so that
+/// it meets the requirements of the MutableBufferSequence concept.
 class mutable_buffers_1
   : public mutable_buffer
 {
@@ -165,30 +168,40 @@ class mutable_buffers_1
   typedef const mutable_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
-  mutable_buffers_1(void* data, std::size_t size)
+  mutable_buffers_1(void* data, std::size_t size) ASIO_NOEXCEPT
     : mutable_buffer(data, size)
   {
   }
 
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+  mutable_buffers_1(void* data, std::size_t size,
+      asio::detail::function<void()> debug_check)
+    : mutable_buffer(data, size, debug_check)
+  {
+  }
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+
   /// Construct to represent a single modifiable buffer.
-  explicit mutable_buffers_1(const mutable_buffer& b)
+  explicit mutable_buffers_1(const mutable_buffer& b) ASIO_NOEXCEPT
     : mutable_buffer(b)
   {
   }
 
   /// Get a random-access iterator to the first element.
-  const_iterator begin() const
+  const_iterator begin() const ASIO_NOEXCEPT
   {
     return this;
   }
 
   /// Get a random-access iterator for one past the last element.
-  const_iterator end() const
+  const_iterator end() const ASIO_NOEXCEPT
   {
     return begin() + 1;
   }
 };
 
+#endif // !defined(ASIO_NO_DEPRECATED)
+
 /// Holds a buffer that cannot be modified.
 /**
  * The const_buffer class provides a safe representation of a buffer that cannot
@@ -197,38 +210,38 @@ class mutable_buffers_1
  *
  * @par Accessing Buffer Contents
  *
- * The contents of a buffer may be accessed using the @ref buffer_size
- * and @ref buffer_cast functions:
+ * The contents of a buffer may be accessed using the @c data() and @c size()
+ * member functions:
  *
  * @code asio::const_buffer b1 = ...;
- * std::size_t s1 = asio::buffer_size(b1);
- * const unsigned char* p1 = asio::buffer_cast<const unsigned char*>(b1);
+ * std::size_t s1 = b1.size();
+ * const unsigned char* p1 = static_cast<const unsigned char*>(b1.data());
  * @endcode
  *
- * The asio::buffer_cast function permits violations of type safety, so
- * uses of it in application code should be carefully considered.
+ * The @c data() member function permits violations of type safety, so uses of
+ * it in application code should be carefully considered.
  */
 class const_buffer
 {
 public:
   /// Construct an empty buffer.
-  const_buffer()
+  const_buffer() ASIO_NOEXCEPT
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
-  const_buffer(const void* data, std::size_t size)
+  const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
     : data_(data),
       size_(size)
   {
   }
 
   /// Construct a non-modifiable buffer from a modifiable one.
-  const_buffer(const mutable_buffer& b)
-    : data_(asio::detail::buffer_cast_helper(b)),
-      size_(asio::detail::buffer_size_helper(b))
+  const_buffer(const mutable_buffer& b) ASIO_NOEXCEPT
+    : data_(b.data()),
+      size_(b.size())
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
       , debug_check_(b.get_debug_check())
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
@@ -250,12 +263,32 @@ class const_buffer
   }
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
 
-private:
-  friend const void* asio::detail::buffer_cast_helper(
-      const const_buffer& b);
-  friend std::size_t asio::detail::buffer_size_helper(
-      const const_buffer& b);
+  /// Get a pointer to the beginning of the memory range.
+  const void* data() const ASIO_NOEXCEPT
+  {
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+    if (size_ && debug_check_)
+      debug_check_();
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+    return data_;
+  }
+
+  /// Get the size of the memory range.
+  std::size_t size() const ASIO_NOEXCEPT
+  {
+    return size_;
+  }
+
+  /// Move the start of the buffer by the specified number of bytes.
+  const_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
+  {
+    std::size_t offset = n < size_ ? n : size_;
+    data_ = static_cast<const char*>(data_) + offset;
+    size_ -= offset;
+    return *this;
+  }
 
+private:
   const void* data_;
   std::size_t size_;
 
@@ -264,26 +297,10 @@ class const_buffer
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
-namespace detail {
-
-inline const void* buffer_cast_helper(const const_buffer& b)
-{
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  if (b.size_ && b.debug_check_)
-    b.debug_check_();
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-  return b.data_;
-}
-
-inline std::size_t buffer_size_helper(const const_buffer& b)
-{
-  return b.size_;
-}
-
-} // namespace detail
+#if !defined(ASIO_NO_DEPRECATED)
 
-/// Adapts a single non-modifiable buffer so that it meets the requirements of
-/// the ConstBufferSequence concept.
+/// (Deprecated: Use const_buffer.) Adapts a single non-modifiable buffer so
+/// that it meets the requirements of the ConstBufferSequence concept.
 class const_buffers_1
   : public const_buffer
 {
@@ -295,32 +312,78 @@ class const_buffers_1
   typedef const const_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
-  const_buffers_1(const void* data, std::size_t size)
+  const_buffers_1(const void* data, std::size_t size) ASIO_NOEXCEPT
     : const_buffer(data, size)
   {
   }
 
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+  const_buffers_1(const void* data, std::size_t size,
+      asio::detail::function<void()> debug_check)
+    : const_buffer(data, size, debug_check)
+  {
+  }
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+
   /// Construct to represent a single non-modifiable buffer.
-  explicit const_buffers_1(const const_buffer& b)
+  explicit const_buffers_1(const const_buffer& b) ASIO_NOEXCEPT
     : const_buffer(b)
   {
   }
 
   /// Get a random-access iterator to the first element.
-  const_iterator begin() const
+  const_iterator begin() const ASIO_NOEXCEPT
   {
     return this;
   }
 
   /// Get a random-access iterator for one past the last element.
-  const_iterator end() const
+  const_iterator end() const ASIO_NOEXCEPT
   {
     return begin() + 1;
   }
 };
 
-/// An implementation of both the ConstBufferSequence and MutableBufferSequence
-/// concepts to represent a null buffer sequence.
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+/// Trait to determine whether a type satisfies the MutableBufferSequence
+/// requirements.
+template <typename T>
+struct is_mutable_buffer_sequence
+#if defined(GENERATING_DOCUMENTATION)
+  : integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  : asio::detail::is_buffer_sequence<T, mutable_buffer>
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+/// Trait to determine whether a type satisfies the ConstBufferSequence
+/// requirements.
+template <typename T>
+struct is_const_buffer_sequence
+#if defined(GENERATING_DOCUMENTATION)
+  : integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  : asio::detail::is_buffer_sequence<T, const_buffer>
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+/// Trait to determine whether a type satisfies the DynamicBuffer requirements.
+template <typename T>
+struct is_dynamic_buffer
+#if defined(GENERATING_DOCUMENTATION)
+  : integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  : asio::detail::is_dynamic_buffer<T>
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+/// (Deprecated: Use the socket/descriptor wait() and async_wait() member
+/// functions.) An implementation of both the ConstBufferSequence and
+/// MutableBufferSequence concepts to represent a null buffer sequence.
 class null_buffers
 {
 public:
@@ -331,13 +394,13 @@ class null_buffers
   typedef const mutable_buffer* const_iterator;
 
   /// Get a random-access iterator to the first element.
-  const_iterator begin() const
+  const_iterator begin() const ASIO_NOEXCEPT
   {
     return &buf_;
   }
 
   /// Get a random-access iterator for one past the last element.
-  const_iterator end() const
+  const_iterator end() const ASIO_NOEXCEPT
   {
     return &buf_;
   }
@@ -346,61 +409,189 @@ class null_buffers
   mutable_buffer buf_;
 };
 
-/** @defgroup buffer_size asio::buffer_size
+/** @defgroup buffer_sequence_begin asio::buffer_sequence_begin
  *
- * @brief The asio::buffer_size function determines the total number of
- * bytes in a buffer or buffer sequence.
+ * @brief The asio::buffer_sequence_begin function returns an iterator
+ * pointing to the first element in a buffer sequence.
  */
 /*@{*/
 
-/// Get the number of bytes in a modifiable buffer.
-inline std::size_t buffer_size(const mutable_buffer& b)
+/// Get an iterator to the first element in a buffer sequence.
+inline const mutable_buffer* buffer_sequence_begin(const mutable_buffer& b)
 {
-  return detail::buffer_size_helper(b);
+  return &b;
 }
 
-/// Get the number of bytes in a modifiable buffer.
-inline std::size_t buffer_size(const mutable_buffers_1& b)
+/// Get an iterator to the first element in a buffer sequence.
+inline const const_buffer* buffer_sequence_begin(const const_buffer& b)
 {
-  return detail::buffer_size_helper(b);
+  return &b;
 }
 
-/// Get the number of bytes in a non-modifiable buffer.
-inline std::size_t buffer_size(const const_buffer& b)
+#if defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
+
+/// Get an iterator to the first element in a buffer sequence.
+template <typename C>
+inline auto buffer_sequence_begin(C& c) -> decltype(c.begin())
 {
-  return detail::buffer_size_helper(b);
+  return c.begin();
 }
 
-/// Get the number of bytes in a non-modifiable buffer.
-inline std::size_t buffer_size(const const_buffers_1& b)
+/// Get an iterator to the first element in a buffer sequence.
+template <typename C>
+inline auto buffer_sequence_begin(const C& c) -> decltype(c.begin())
 {
-  return detail::buffer_size_helper(b);
+  return c.begin();
 }
 
-/// 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.
+#else // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
+
+template <typename C>
+inline typename C::iterator buffer_sequence_begin(C& c)
+{
+  return c.begin();
+}
+
+template <typename C>
+inline typename C::const_iterator buffer_sequence_begin(const C& c)
+{
+  return c.begin();
+}
+
+#endif // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
+
+/*@}*/
+
+/** @defgroup buffer_sequence_end asio::buffer_sequence_end
+ *
+ * @brief The asio::buffer_sequence_end function returns an iterator
+ * pointing to one past the end element in a buffer sequence.
  */
+/*@{*/
+
+/// Get an iterator to one past the end element in a buffer sequence.
+inline const mutable_buffer* buffer_sequence_end(const mutable_buffer& b)
+{
+  return &b + 1;
+}
+
+/// Get an iterator to one past the end element in a buffer sequence.
+inline const const_buffer* buffer_sequence_end(const const_buffer& b)
+{
+  return &b + 1;
+}
+
+#if defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
+
+/// Get an iterator to one past the end element in a buffer sequence.
+template <typename C>
+inline auto buffer_sequence_end(C& c) -> decltype(c.end())
+{
+  return c.end();
+}
+
+/// Get an iterator to one past the end element in a buffer sequence.
+template <typename C>
+inline auto buffer_sequence_end(const C& c) -> decltype(c.end())
+{
+  return c.end();
+}
+
+#else // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
+
+template <typename C>
+inline typename C::iterator buffer_sequence_end(C& c)
+{
+  return c.end();
+}
+
+template <typename C>
+inline typename C::const_iterator buffer_sequence_end(const C& c)
+{
+  return c.end();
+}
+
+#endif // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
+
+/*@}*/
+
+namespace detail {
+
+// Tag types used to select appropriately optimised overloads.
+struct one_buffer {};
+struct multiple_buffers {};
+
+// Helper trait to detect single buffers.
 template <typename BufferSequence>
-inline std::size_t buffer_size(const BufferSequence& b)
+struct buffer_sequence_cardinality :
+  conditional<
+    is_same<BufferSequence, mutable_buffer>::value
+#if !defined(ASIO_NO_DEPRECATED)
+      || is_same<BufferSequence, mutable_buffers_1>::value
+      || is_same<BufferSequence, const_buffers_1>::value
+#endif // !defined(ASIO_NO_DEPRECATED)
+      || is_same<BufferSequence, const_buffer>::value,
+    one_buffer, multiple_buffers>::type {};
+
+template <typename Iterator>
+inline std::size_t buffer_size(one_buffer,
+    Iterator begin, Iterator) ASIO_NOEXCEPT
+{
+  return const_buffer(*begin).size();
+}
+
+template <typename Iterator>
+inline std::size_t buffer_size(multiple_buffers,
+    Iterator begin, Iterator end) ASIO_NOEXCEPT
 {
   std::size_t total_buffer_size = 0;
 
-  typename BufferSequence::const_iterator iter = b.begin();
-  typename BufferSequence::const_iterator end = b.end();
+  Iterator iter = begin;
   for (; iter != end; ++iter)
-    total_buffer_size += detail::buffer_size_helper(*iter);
+  {
+    const_buffer b(*iter);
+    total_buffer_size += b.size();
+  }
 
   return total_buffer_size;
 }
 
-/*@}*/
+} // namespace detail
+
+/// Get the total number of bytes in a buffer sequence.
+/**
+ * The @c buffer_size function determines the total size of all buffers in the
+ * buffer sequence, as if computed as follows:
+ *
+ * @code size_t total_size = 0;
+ * auto i = asio::buffer_sequence_begin(buffers);
+ * auto end = asio::buffer_sequence_end(buffers);
+ * for (; i != end; ++i)
+ * {
+ *   const_buffer b(*i);
+ *   total_size += b.size();
+ * }
+ * return total_size; @endcode
+ *
+ * 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) ASIO_NOEXCEPT
+{
+  return detail::buffer_size(
+      detail::buffer_sequence_cardinality<BufferSequence>(),
+      asio::buffer_sequence_begin(b),
+      asio::buffer_sequence_end(b));
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
 
 /** @defgroup buffer_cast asio::buffer_cast
  *
- * @brief The asio::buffer_cast function is used to obtain a pointer to
- * the underlying memory region associated with a buffer.
+ * @brief (Deprecated: Use the @c data() member function.) The
+ * asio::buffer_cast function is used to obtain a pointer to the
+ * underlying memory region associated with a buffer.
  *
  * @par Examples:
  *
@@ -421,30 +612,32 @@ inline std::size_t buffer_size(const BufferSequence& b)
 
 /// Cast a non-modifiable buffer to a specified pointer to POD type.
 template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const mutable_buffer& b)
+inline PointerToPodType buffer_cast(const mutable_buffer& b) ASIO_NOEXCEPT
 {
-  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
+  return static_cast<PointerToPodType>(b.data());
 }
 
 /// Cast a non-modifiable buffer to a specified pointer to POD type.
 template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const const_buffer& b)
+inline PointerToPodType buffer_cast(const const_buffer& b) ASIO_NOEXCEPT
 {
-  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
+  return static_cast<PointerToPodType>(b.data());
 }
 
 /*@}*/
 
+#endif // !defined(ASIO_NO_DEPRECATED)
+
 /// 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)
+inline mutable_buffer operator+(const mutable_buffer& b,
+    std::size_t n) ASIO_NOEXCEPT
 {
-  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;
+  std::size_t offset = n < b.size() ? n : b.size();
+  char* new_data = static_cast<char*>(b.data()) + offset;
+  std::size_t new_size = b.size() - offset;
   return mutable_buffer(new_data, new_size
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
       , b.get_debug_check()
@@ -456,29 +649,22 @@ inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
 /**
  * @relates mutable_buffer
  */
-inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
+inline mutable_buffer operator+(std::size_t n,
+    const mutable_buffer& b) ASIO_NOEXCEPT
 {
-  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(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
+  return b + n;
 }
 
 /// 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)
+inline const_buffer operator+(const const_buffer& b,
+    std::size_t n) ASIO_NOEXCEPT
 {
-  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;
+  std::size_t offset = n < b.size() ? n : b.size();
+  const char* new_data = static_cast<const char*>(b.data()) + offset;
+  std::size_t new_size = b.size() - offset;
   return const_buffer(new_data, new_size
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
       , b.get_debug_check()
@@ -490,17 +676,10 @@ inline const_buffer operator+(const const_buffer& b, std::size_t start)
 /**
  * @relates const_buffer
  */
-inline const_buffer operator+(std::size_t start, const const_buffer& b)
+inline const_buffer operator+(std::size_t n,
+    const const_buffer& b) ASIO_NOEXCEPT
 {
-  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(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
+  return b + n;
 }
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
@@ -527,7 +706,7 @@ class buffer_debug_check
 
   void operator()()
   {
-    *iter_;
+    (void)*iter_;
   }
 
 private:
@@ -585,32 +764,33 @@ class buffer_debug_check
  *
  * @par Accessing Buffer Contents
  *
- * The contents of a buffer may be accessed using the @ref buffer_size and
- * @ref buffer_cast functions:
+ * The contents of a buffer may be accessed using the @c data() and @c size()
+ * member functions:
  *
  * @code asio::mutable_buffer b1 = ...;
- * std::size_t s1 = asio::buffer_size(b1);
- * unsigned char* p1 = asio::buffer_cast<unsigned char*>(b1);
+ * std::size_t s1 = b1.size();
+ * unsigned char* p1 = static_cast<unsigned char*>(b1.data());
  *
  * asio::const_buffer b2 = ...;
- * std::size_t s2 = asio::buffer_size(b2);
- * const void* p2 = asio::buffer_cast<const void*>(b2); @endcode
+ * std::size_t s2 = b2.size();
+ * const void* p2 = b2.data(); @endcode
  *
- * The asio::buffer_cast function permits violations of type safety, so
+ * The @c data() member 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.
+ * For convenience, a @ref buffer_size function is provided that works with
+ * both buffers and 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:
+*
+ * In particular, when used with the @ref buffer_size function, the @ref
+ * buffer_copy function can be used to linearise a sequence of buffers. For
+ * example:
  *
  * @code vector<const_buffer> buffers = ...;
  *
@@ -699,29 +879,38 @@ class buffer_debug_check
  */
 /*@{*/
 
+#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+# define ASIO_MUTABLE_BUFFER mutable_buffer
+# define ASIO_CONST_BUFFER const_buffer
+#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+# define ASIO_MUTABLE_BUFFER mutable_buffers_1
+# define ASIO_CONST_BUFFER const_buffers_1
+#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
+
 /// Create a new modifiable buffer from an existing buffer.
 /**
- * @returns <tt>mutable_buffers_1(b)</tt>.
+ * @returns <tt>mutable_buffer(b)</tt>.
  */
-inline mutable_buffers_1 buffer(const mutable_buffer& b)
+inline ASIO_MUTABLE_BUFFER buffer(
+    const mutable_buffer& b) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(b);
+  return ASIO_MUTABLE_BUFFER(b);
 }
 
 /// Create a new modifiable buffer from an existing buffer.
 /**
- * @returns A mutable_buffers_1 value equivalent to:
- * @code mutable_buffers_1(
- *     buffer_cast<void*>(b),
- *     min(buffer_size(b), max_size_in_bytes)); @endcode
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
+ *     b.data(),
+ *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline mutable_buffers_1 buffer(const mutable_buffer& b,
-    std::size_t max_size_in_bytes)
+inline ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(buffer_cast<void*>(b),
-        buffer_size(b) < max_size_in_bytes
-        ? buffer_size(b) : max_size_in_bytes
+  return ASIO_MUTABLE_BUFFER(
+      mutable_buffer(b.data(),
+        b.size() < max_size_in_bytes
+        ? b.size() : max_size_in_bytes
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
         , b.get_debug_check()
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
@@ -730,110 +919,110 @@ inline mutable_buffers_1 buffer(const mutable_buffer& b,
 
 /// Create a new non-modifiable buffer from an existing buffer.
 /**
- * @returns <tt>const_buffers_1(b)</tt>.
+ * @returns <tt>const_buffer(b)</tt>.
  */
-inline const_buffers_1 buffer(const const_buffer& b)
+inline ASIO_CONST_BUFFER buffer(
+    const const_buffer& b) ASIO_NOEXCEPT
 {
-  return const_buffers_1(b);
+  return ASIO_CONST_BUFFER(b);
 }
 
 /// Create a new non-modifiable buffer from an existing buffer.
 /**
- * @returns A const_buffers_1 value equivalent to:
- * @code const_buffers_1(
- *     buffer_cast<const void*>(b),
- *     min(buffer_size(b), max_size_in_bytes)); @endcode
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     b.data(),
+ *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline const_buffers_1 buffer(const const_buffer& b,
-    std::size_t max_size_in_bytes)
+inline ASIO_CONST_BUFFER buffer(const const_buffer& b,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(buffer_cast<const void*>(b),
-        buffer_size(b) < max_size_in_bytes
-        ? buffer_size(b) : max_size_in_bytes
+  return ASIO_CONST_BUFFER(b.data(),
+      b.size() < max_size_in_bytes
+      ? b.size() : max_size_in_bytes
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-        , b.get_debug_check()
+      , b.get_debug_check()
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
-        ));
+      );
 }
 
 /// Create a new modifiable buffer that represents the given memory range.
 /**
- * @returns <tt>mutable_buffers_1(data, size_in_bytes)</tt>.
+ * @returns <tt>mutable_buffer(data, size_in_bytes)</tt>.
  */
-inline mutable_buffers_1 buffer(void* data, std::size_t size_in_bytes)
+inline ASIO_MUTABLE_BUFFER buffer(void* data,
+    std::size_t size_in_bytes) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(mutable_buffer(data, size_in_bytes));
+  return ASIO_MUTABLE_BUFFER(data, size_in_bytes);
 }
 
 /// Create a new non-modifiable buffer that represents the given memory range.
 /**
- * @returns <tt>const_buffers_1(data, size_in_bytes)</tt>.
+ * @returns <tt>const_buffer(data, size_in_bytes)</tt>.
  */
-inline const_buffers_1 buffer(const void* data,
-    std::size_t size_in_bytes)
+inline ASIO_CONST_BUFFER buffer(const void* data,
+    std::size_t size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(const_buffer(data, size_in_bytes));
+  return ASIO_CONST_BUFFER(data, size_in_bytes);
 }
 
 /// Create a new modifiable buffer that represents the given POD array.
 /**
- * @returns A mutable_buffers_1 value equivalent to:
- * @code mutable_buffers_1(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     static_cast<void*>(data),
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline mutable_buffers_1 buffer(PodType (&data)[N])
+inline ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(mutable_buffer(data, N * sizeof(PodType)));
+  return ASIO_MUTABLE_BUFFER(data, N * 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(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     static_cast<void*>(data),
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline mutable_buffers_1 buffer(PodType (&data)[N],
-    std::size_t max_size_in_bytes)
+inline ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(data,
-        N * sizeof(PodType) < max_size_in_bytes
-        ? N * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_MUTABLE_BUFFER(data,
+      N * sizeof(PodType) < max_size_in_bytes
+      ? N * 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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     static_cast<const void*>(data),
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(const PodType (&data)[N])
+inline ASIO_CONST_BUFFER buffer(
+    const PodType (&data)[N]) ASIO_NOEXCEPT
 {
-  return const_buffers_1(const_buffer(data, N * sizeof(PodType)));
+  return ASIO_CONST_BUFFER(data, N * 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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     static_cast<const void*>(data),
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(const PodType (&data)[N],
-    std::size_t max_size_in_bytes)
+inline ASIO_CONST_BUFFER buffer(const PodType (&data)[N],
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data,
-        N * sizeof(PodType) < max_size_in_bytes
-        ? N * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_CONST_BUFFER(data,
+      N * sizeof(PodType) < max_size_in_bytes
+      ? N * sizeof(PodType) : max_size_in_bytes);
 }
 
 #if defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
@@ -859,14 +1048,14 @@ template <>
 struct buffer_types_base<false>
 {
   typedef mutable_buffer buffer_type;
-  typedef mutable_buffers_1 container_type;
+  typedef ASIO_MUTABLE_BUFFER container_type;
 };
 
 template <>
 struct buffer_types_base<true>
 {
   typedef const_buffer buffer_type;
-  typedef const_buffers_1 container_type;
+  typedef ASIO_CONST_BUFFER container_type;
 };
 
 template <typename PodType>
@@ -879,7 +1068,7 @@ struct buffer_types
 
 template <typename PodType, std::size_t N>
 inline typename detail::buffer_types<PodType>::container_type
-buffer(boost::array<PodType, N>& data)
+buffer(boost::array<PodType, N>& data) ASIO_NOEXCEPT
 {
   typedef typename asio::detail::buffer_types<PodType>::buffer_type
     buffer_type;
@@ -891,7 +1080,8 @@ buffer(boost::array<PodType, N>& data)
 
 template <typename PodType, std::size_t N>
 inline typename detail::buffer_types<PodType>::container_type
-buffer(boost::array<PodType, N>& data, std::size_t max_size_in_bytes)
+buffer(boost::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
   typedef typename asio::detail::buffer_types<PodType>::buffer_type
     buffer_type;
@@ -907,200 +1097,195 @@ buffer(boost::array<PodType, N>& data, std::size_t max_size_in_bytes)
 
 /// Create a new modifiable buffer that represents the given POD array.
 /**
- * @returns A mutable_buffers_1 value equivalent to:
- * @code mutable_buffers_1(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     data.data(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline mutable_buffers_1 buffer(boost::array<PodType, N>& data)
+inline ASIO_MUTABLE_BUFFER buffer(
+    boost::array<PodType, N>& data) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(data.c_array(), data.size() * sizeof(PodType)));
+  return ASIO_MUTABLE_BUFFER(
+      data.c_array(), 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(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     data.data(),
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline mutable_buffers_1 buffer(boost::array<PodType, N>& data,
-    std::size_t max_size_in_bytes)
+inline ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(data.c_array(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_MUTABLE_BUFFER(data.c_array(),
+      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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     data.data(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(boost::array<const PodType, N>& data)
+inline ASIO_CONST_BUFFER buffer(
+    boost::array<const PodType, N>& data) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(), data.size() * sizeof(PodType)));
+  return ASIO_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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     data.data(),
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(boost::array<const PodType, N>& data,
-    std::size_t max_size_in_bytes)
+inline ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_CONST_BUFFER(data.data(),
+      data.size() * sizeof(PodType) < max_size_in_bytes
+      ? data.size() * sizeof(PodType) : max_size_in_bytes);
 }
 
 #endif // defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
 
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
- * @returns A const_buffers_1 value equivalent to:
- * @code const_buffers_1(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     data.data(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(const boost::array<PodType, N>& data)
+inline ASIO_CONST_BUFFER buffer(
+    const boost::array<PodType, N>& data) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(), data.size() * sizeof(PodType)));
+  return ASIO_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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     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 boost::array<PodType, N>& data,
-    std::size_t max_size_in_bytes)
+inline ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_CONST_BUFFER(data.data(),
+      data.size() * sizeof(PodType) < max_size_in_bytes
+      ? data.size() * sizeof(PodType) : max_size_in_bytes);
 }
 
 #if defined(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(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     data.data(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline mutable_buffers_1 buffer(std::array<PodType, N>& data)
+inline ASIO_MUTABLE_BUFFER buffer(
+    std::array<PodType, N>& data) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(data.data(), data.size() * sizeof(PodType)));
+  return ASIO_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(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     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)
+inline ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(data.data(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     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)
+inline ASIO_CONST_BUFFER buffer(
+    std::array<const PodType, N>& data) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(), data.size() * sizeof(PodType)));
+  return ASIO_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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     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)
+inline ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     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)
+inline ASIO_CONST_BUFFER buffer(
+    const std::array<PodType, N>& data) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(), data.size() * sizeof(PodType)));
+  return ASIO_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(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     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)
+inline ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
+  return ASIO_CONST_BUFFER(data.data(),
+      data.size() * sizeof(PodType) < max_size_in_bytes
+      ? data.size() * sizeof(PodType) : max_size_in_bytes);
 }
 
 #endif // defined(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:
- * @code mutable_buffers_1(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     data.size() ? &data[0] : 0,
  *     data.size() * sizeof(PodType)); @endcode
  *
@@ -1108,22 +1293,23 @@ inline const_buffers_1 buffer(const std::array<PodType, N>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data)
+inline ASIO_MUTABLE_BUFFER buffer(
+    std::vector<PodType, Allocator>& data) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
+  return ASIO_MUTABLE_BUFFER(
+      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::vector<PodType, Allocator>::iterator
-          >(data.begin())
+      , detail::buffer_debug_check<
+          typename std::vector<PodType, Allocator>::iterator
+        >(data.begin())
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
-        ));
+      );
 }
 
 /// Create a new modifiable buffer that represents the given POD vector.
 /**
- * @returns A mutable_buffers_1 value equivalent to:
- * @code mutable_buffers_1(
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
  *     data.size() ? &data[0] : 0,
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  *
@@ -1131,25 +1317,24 @@ inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data)
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
-    std::size_t max_size_in_bytes)
+inline ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return mutable_buffers_1(
-      mutable_buffer(data.size() ? &data[0] : 0,
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes
+  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
+      data.size() * sizeof(PodType) < max_size_in_bytes
+      ? data.size() * sizeof(PodType) : max_size_in_bytes
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::vector<PodType, Allocator>::iterator
-          >(data.begin())
+      , detail::buffer_debug_check<
+          typename std::vector<PodType, Allocator>::iterator
+        >(data.begin())
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
-        ));
+      );
 }
 
 /// Create a new non-modifiable buffer that represents the given POD vector.
 /**
- * @returns A const_buffers_1 value equivalent to:
- * @code const_buffers_1(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     data.size() ? &data[0] : 0,
  *     data.size() * sizeof(PodType)); @endcode
  *
@@ -1157,23 +1342,23 @@ inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline const_buffers_1 buffer(
-    const std::vector<PodType, Allocator>& data)
+inline ASIO_CONST_BUFFER buffer(
+    const std::vector<PodType, Allocator>& data) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
+  return ASIO_CONST_BUFFER(
+      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::vector<PodType, Allocator>::const_iterator
-          >(data.begin())
+      , detail::buffer_debug_check<
+          typename std::vector<PodType, Allocator>::const_iterator
+        >(data.begin())
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
-        ));
+      );
 }
 
 /// Create a new non-modifiable buffer that represents the given POD vector.
 /**
- * @returns A const_buffers_1 value equivalent to:
- * @code const_buffers_1(
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
  *     data.size() ? &data[0] : 0,
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  *
@@ -1181,963 +1366,730 @@ inline const_buffers_1 buffer(
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline const_buffers_1 buffer(
-    const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes)
+inline ASIO_CONST_BUFFER buffer(
+    const std::vector<PodType, Allocator>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.size() ? &data[0] : 0,
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes
+  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
+      data.size() * sizeof(PodType) < max_size_in_bytes
+      ? data.size() * sizeof(PodType) : max_size_in_bytes
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::vector<PodType, Allocator>::const_iterator
-          >(data.begin())
+      , detail::buffer_debug_check<
+          typename std::vector<PodType, Allocator>::const_iterator
+        >(data.begin())
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
-        ));
+      );
 }
 
-/// Create a new non-modifiable buffer that represents the given string.
+/// Create a new modifiable buffer that represents the given string.
 /**
- * @returns <tt>const_buffers_1(data.data(), data.size() * sizeof(Elem))</tt>.
+ * @returns <tt>mutable_buffer(data.size() ? &data[0] : 0,
+ * data.size() * sizeof(Elem))</tt>.
  *
  * @note The buffer is invalidated by any non-const operation called on the
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline const_buffers_1 buffer(
-    const std::basic_string<Elem, Traits, Allocator>& data)
+inline ASIO_MUTABLE_BUFFER buffer(
+    std::basic_string<Elem, Traits, Allocator>& data) ASIO_NOEXCEPT
 {
-  return const_buffers_1(const_buffer(data.data(), data.size() * sizeof(Elem)
+  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
+      data.size() * sizeof(Elem)
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::basic_string<Elem, Traits, Allocator>::const_iterator
-          >(data.begin())
+      , detail::buffer_debug_check<
+          typename std::basic_string<Elem, Traits, Allocator>::iterator
+        >(data.begin())
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
-        ));
+      );
 }
 
 /// Create a new non-modifiable buffer that represents the given string.
 /**
- * @returns A const_buffers_1 value equivalent to:
- * @code const_buffers_1(
- *     data.data(),
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
+ *     data.size() ? &data[0] : 0,
  *     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.
  */
 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)
+inline ASIO_MUTABLE_BUFFER buffer(
+    std::basic_string<Elem, Traits, Allocator>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return const_buffers_1(
-      const_buffer(data.data(),
-        data.size() * sizeof(Elem) < max_size_in_bytes
-        ? data.size() * sizeof(Elem) : max_size_in_bytes
+  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
+      data.size() * sizeof(Elem) < max_size_in_bytes
+      ? data.size() * sizeof(Elem) : max_size_in_bytes
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::basic_string<Elem, Traits, Allocator>::const_iterator
-          >(data.begin())
+      , detail::buffer_debug_check<
+          typename std::basic_string<Elem, Traits, Allocator>::iterator
+        >(data.begin())
 #endif // ASIO_ENABLE_BUFFER_DEBUGGING
-        ));
+      );
 }
 
-/*@}*/
-
-/** @defgroup buffer_copy asio::buffer_copy
- *
- * @brief The 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.
+/// Create a new non-modifiable buffer that represents the given string.
+/**
+ * @returns <tt>const_buffer(data.data(), data.size() * sizeof(Elem))</tt>.
  *
- * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
- * consequently it cannot be used to copy between overlapping memory regions.
+ * @note The buffer is invalidated by any non-const operation called on the
+ * given string object.
  */
-/*@{*/
+template <typename Elem, typename Traits, typename Allocator>
+inline ASIO_CONST_BUFFER buffer(
+    const std::basic_string<Elem, Traits, Allocator>& data) ASIO_NOEXCEPT
+{
+  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(Elem)
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+      , detail::buffer_debug_check<
+          typename std::basic_string<Elem, Traits, Allocator>::const_iterator
+        >(data.begin())
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
 
-/// Copies bytes from a source buffer to a target buffer.
+/// Create a new non-modifiable buffer that represents the given string.
 /**
- * @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)
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.data(),
+ *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
  *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * @note The buffer is invalidated by any non-const operation called on the
+ * given string object.
  */
-inline std::size_t buffer_copy(const mutable_buffer& target,
-    const const_buffer& source)
+template <typename Elem, typename Traits, typename Allocator>
+inline ASIO_CONST_BUFFER buffer(
+    const std::basic_string<Elem, Traits, Allocator>& data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  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;
+  return ASIO_CONST_BUFFER(data.data(),
+      data.size() * sizeof(Elem) < max_size_in_bytes
+      ? data.size() * sizeof(Elem) : max_size_in_bytes
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+      , detail::buffer_debug_check<
+          typename std::basic_string<Elem, Traits, Allocator>::const_iterator
+        >(data.begin())
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+      );
 }
 
-/// Copies bytes from a source buffer to a target buffer.
+#if defined(ASIO_HAS_STRING_VIEW) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Create a new modifiable buffer that represents the given string_view.
 /**
- * @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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * @returns <tt>mutable_buffer(data.size() ? &data[0] : 0,
+ * data.size() * sizeof(Elem))</tt>.
  */
-inline std::size_t buffer_copy(const mutable_buffer& target,
-    const const_buffers_1& source)
+template <typename Elem, typename Traits>
+inline ASIO_CONST_BUFFER buffer(
+    basic_string_view<Elem, Traits> data) ASIO_NOEXCEPT
 {
-  return buffer_copy(target, static_cast<const const_buffer&>(source));
+  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
+      data.size() * sizeof(Elem)
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+      , detail::buffer_debug_check<
+          typename basic_string_view<Elem, Traits>::iterator
+        >(data.begin())
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+      );
 }
 
-/// Copies bytes from a source buffer to a target buffer.
+/// Create a new non-modifiable buffer that represents the given string.
 /**
- * @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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
  */
-inline std::size_t buffer_copy(const mutable_buffer& target,
-    const mutable_buffer& source)
+template <typename Elem, typename Traits>
+inline ASIO_CONST_BUFFER buffer(
+    basic_string_view<Elem, Traits> data,
+    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
 {
-  return buffer_copy(target, const_buffer(source));
+  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
+      data.size() * sizeof(Elem) < max_size_in_bytes
+      ? data.size() * sizeof(Elem) : max_size_in_bytes
+#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
+      , detail::buffer_debug_check<
+          typename basic_string_view<Elem, Traits>::iterator
+        >(data.begin())
+#endif // ASIO_ENABLE_BUFFER_DEBUGGING
+      );
 }
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-inline std::size_t buffer_copy(const mutable_buffer& target,
-    const mutable_buffers_1& source)
-{
-  return buffer_copy(target, const_buffer(source));
-}
+#endif // defined(ASIO_HAS_STRING_VIEW)
+       //  || defined(GENERATING_DOCUMENTATION)
+
+/*@}*/
 
-/// Copies bytes from a source buffer sequence to a target buffer.
+/// Adapt a basic_string to the DynamicBuffer requirements.
 /**
- * @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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * Requires that <tt>sizeof(Elem) == 1</tt>.
  */
-template <typename ConstBufferSequence>
-std::size_t buffer_copy(const mutable_buffer& target,
-    const ConstBufferSequence& source)
+template <typename Elem, typename Traits, typename Allocator>
+class dynamic_string_buffer
 {
-  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)
+public:
+  /// The type used to represent the input sequence as a list of buffers.
+  typedef ASIO_CONST_BUFFER const_buffers_type;
+
+  /// The type used to represent the output sequence as a list of buffers.
+  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;
+
+  /// Construct a dynamic buffer from a string.
+  /**
+   * @param s The string to be used as backing storage for the dynamic buffer.
+   * Any existing data in the string is treated as the dynamic buffer's input
+   * sequence. The object stores a reference to the string and the user is
+   * responsible for ensuring that the string object remains valid until the
+   * dynamic_string_buffer object is destroyed.
+   *
+   * @param maximum_size Specifies a maximum size for the buffer, in bytes.
+   */
+  explicit dynamic_string_buffer(std::basic_string<Elem, Traits, Allocator>& s,
+      std::size_t maximum_size =
+        (std::numeric_limits<std::size_t>::max)()) ASIO_NOEXCEPT
+    : string_(s),
+      size_(string_.size()),
+      max_size_(maximum_size)
   {
-    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;
-}
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move construct a dynamic buffer.
+  dynamic_string_buffer(dynamic_string_buffer&& other) ASIO_NOEXCEPT
+    : string_(other.string_),
+      size_(other.size_),
+      max_size_(other.max_size_)
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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);
-}
+  /// Get the size of the input sequence.
+  std::size_t size() const ASIO_NOEXCEPT
+  {
+    return size_;
+  }
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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));
-}
+  /// Get the maximum size of the dynamic buffer.
+  /**
+   * @returns The allowed maximum of the sum of the sizes of the input sequence
+   * and output sequence.
+   */
+  std::size_t max_size() const ASIO_NOEXCEPT
+  {
+    return max_size_;
+  }
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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));
-}
+  /// Get the current capacity of the dynamic buffer.
+  /**
+   * @returns The current total capacity of the buffer, i.e. for both the input
+   * sequence and output sequence.
+   */
+  std::size_t capacity() const ASIO_NOEXCEPT
+  {
+    return string_.capacity();
+  }
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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));
-}
+  /// Get a list of buffers that represents the input sequence.
+  /**
+   * @returns An object of type @c const_buffers_type that satisfies
+   * ConstBufferSequence requirements, representing the basic_string memory in
+   * input sequence.
+   *
+   * @note The returned object is invalidated by any @c dynamic_string_buffer
+   * or @c basic_string member function that modifies the input sequence or
+   * output sequence.
+   */
+  const_buffers_type data() const ASIO_NOEXCEPT
+  {
+    return const_buffers_type(asio::buffer(string_, size_));
+  }
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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);
-}
+  /// Get a list of buffers that represents the output sequence, with the given
+  /// size.
+  /**
+   * Ensures that the output sequence can accommodate @c n bytes, resizing the
+   * basic_string object as necessary.
+   *
+   * @returns An object of type @c mutable_buffers_type that satisfies
+   * MutableBufferSequence requirements, representing basic_string memory
+   * at the start of the output sequence of size @c n.
+   *
+   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
+   *
+   * @note The returned object is invalidated by any @c dynamic_string_buffer
+   * or @c basic_string member function that modifies the input sequence or
+   * output sequence.
+   */
+  mutable_buffers_type prepare(std::size_t n)
+  {
+    if (size () > max_size() || max_size() - size() < n)
+    {
+      std::length_error ex("dynamic_string_buffer too long");
+      asio::detail::throw_exception(ex);
+    }
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-template <typename MutableBufferSequence>
-std::size_t buffer_copy(const MutableBufferSequence& target,
-    const const_buffer& source)
-{
-  std::size_t total_bytes_copied = 0;
+    string_.resize(size_ + n);
 
-  typename MutableBufferSequence::const_iterator target_iter = target.begin();
-  typename MutableBufferSequence::const_iterator target_end = target.end();
+    return asio::buffer(asio::buffer(string_) + size_, n);
+  }
 
-  for (const_buffer source_buffer(source);
-      buffer_size(source_buffer) && target_iter != target_end; ++target_iter)
+  /// Move bytes from the output sequence to the input sequence.
+  /**
+   * @param n The number of bytes to append from the start of the output
+   * sequence to the end of the input sequence. The remainder of the output
+   * sequence is discarded.
+   *
+   * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
+   * no intervening operations that modify the input or output sequence.
+   *
+   * @note If @c n is greater than the size of the output sequence, the entire
+   * output sequence is moved to the input sequence and no error is issued.
+   */
+  void commit(std::size_t n)
   {
-    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;
+    size_ += (std::min)(n, string_.size() - size_);
+    string_.resize(size_);
   }
 
-  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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-template <typename MutableBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const mutable_buffer& source)
-{
-  return buffer_copy(target, const_buffer(source));
-}
+  /// Remove characters from the input sequence.
+  /**
+   * Removes @c n characters from the beginning of the input sequence.
+   *
+   * @note If @c n is greater than the size of the input sequence, the entire
+   * input sequence is consumed and no error is issued.
+   */
+  void consume(std::size_t n)
+  {
+    std::size_t consume_length = (std::min)(n, size_);
+    string_.erase(0, consume_length);
+    size_ -= consume_length;
+  }
 
-/// 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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-template <typename MutableBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const mutable_buffers_1& source)
-{
-  return buffer_copy(target, const_buffer(source));
-}
+private:
+  std::basic_string<Elem, Traits, Allocator>& string_;
+  std::size_t size_;
+  const std::size_t max_size_;
+};
 
-/// Copies bytes from a source buffer sequence to a target buffer sequence.
+/// Adapt a vector to the DynamicBuffer requirements.
 /**
- * @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)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * Requires that <tt>sizeof(Elem) == 1</tt>.
  */
-template <typename MutableBufferSequence, typename ConstBufferSequence>
-std::size_t buffer_copy(const MutableBufferSequence& target,
-    const ConstBufferSequence& source)
+template <typename Elem, typename Allocator>
+class dynamic_vector_buffer
 {
-  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;
+public:
+  /// The type used to represent the input sequence as a list of buffers.
+  typedef ASIO_CONST_BUFFER const_buffers_type;
+
+  /// The type used to represent the output sequence as a list of buffers.
+  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;
+
+  /// Construct a dynamic buffer from a string.
+  /**
+   * @param v The vector to be used as backing storage for the dynamic buffer.
+   * Any existing data in the vector is treated as the dynamic buffer's input
+   * sequence. The object stores a reference to the vector and the user is
+   * responsible for ensuring that the vector object remains valid until the
+   * dynamic_vector_buffer object is destroyed.
+   *
+   * @param maximum_size Specifies a maximum size for the buffer, in bytes.
+   */
+  explicit dynamic_vector_buffer(std::vector<Elem, Allocator>& v,
+      std::size_t maximum_size =
+        (std::numeric_limits<std::size_t>::max)()) ASIO_NOEXCEPT
+    : vector_(v),
+      size_(vector_.size()),
+      max_size_(maximum_size)
+  {
+  }
 
-  typename ConstBufferSequence::const_iterator source_iter = source.begin();
-  typename ConstBufferSequence::const_iterator source_end = source.end();
-  std::size_t source_buffer_offset = 0;
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move construct a dynamic buffer.
+  dynamic_vector_buffer(dynamic_vector_buffer&& other) ASIO_NOEXCEPT
+    : vector_(other.vector_),
+      size_(other.size_),
+      max_size_(other.max_size_)
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
-  while (target_iter != target_end && source_iter != source_end)
+  /// Get the size of the input sequence.
+  std::size_t size() const ASIO_NOEXCEPT
   {
-    mutable_buffer target_buffer =
-      mutable_buffer(*target_iter) + target_buffer_offset;
+    return size_;
+  }
 
-    const_buffer source_buffer =
-      const_buffer(*source_iter) + source_buffer_offset;
+  /// Get the maximum size of the dynamic buffer.
+  /**
+   * @returns The allowed maximum of the sum of the sizes of the input sequence
+   * and output sequence.
+   */
+  std::size_t max_size() const ASIO_NOEXCEPT
+  {
+    return max_size_;
+  }
 
-    std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
-    total_bytes_copied += bytes_copied;
+  /// Get the current capacity of the dynamic buffer.
+  /**
+   * @returns The current total capacity of the buffer, i.e. for both the input
+   * sequence and output sequence.
+   */
+  std::size_t capacity() const ASIO_NOEXCEPT
+  {
+    return vector_.capacity();
+  }
 
-    if (bytes_copied == buffer_size(target_buffer))
-    {
-      ++target_iter;
-      target_buffer_offset = 0;
-    }
-    else
-      target_buffer_offset += bytes_copied;
+  /// Get a list of buffers that represents the input sequence.
+  /**
+   * @returns An object of type @c const_buffers_type that satisfies
+   * ConstBufferSequence requirements, representing the basic_string memory in
+   * input sequence.
+   *
+   * @note The returned object is invalidated by any @c dynamic_vector_buffer
+   * or @c basic_string member function that modifies the input sequence or
+   * output sequence.
+   */
+  const_buffers_type data() const ASIO_NOEXCEPT
+  {
+    return const_buffers_type(asio::buffer(vector_, size_));
+  }
 
-    if (bytes_copied == buffer_size(source_buffer))
+  /// Get a list of buffers that represents the output sequence, with the given
+  /// size.
+  /**
+   * Ensures that the output sequence can accommodate @c n bytes, resizing the
+   * basic_string object as necessary.
+   *
+   * @returns An object of type @c mutable_buffers_type that satisfies
+   * MutableBufferSequence requirements, representing basic_string memory
+   * at the start of the output sequence of size @c n.
+   *
+   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
+   *
+   * @note The returned object is invalidated by any @c dynamic_vector_buffer
+   * or @c basic_string member function that modifies the input sequence or
+   * output sequence.
+   */
+  mutable_buffers_type prepare(std::size_t n)
+  {
+    if (size () > max_size() || max_size() - size() < n)
     {
-      ++source_iter;
-      source_buffer_offset = 0;
+      std::length_error ex("dynamic_vector_buffer too long");
+      asio::detail::throw_exception(ex);
     }
-    else
-      source_buffer_offset += bytes_copied;
-  }
 
-  return total_bytes_copied;
-}
+    vector_.resize(size_ + n);
 
-/// 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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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);
-}
+    return asio::buffer(asio::buffer(vector_) + size_, n);
+  }
 
-/// 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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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);
-}
+  /// Move bytes from the output sequence to the input sequence.
+  /**
+   * @param n The number of bytes to append from the start of the output
+   * sequence to the end of the input sequence. The remainder of the output
+   * sequence is discarded.
+   *
+   * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
+   * no intervening operations that modify the input or output sequence.
+   *
+   * @note If @c n is greater than the size of the output sequence, the entire
+   * output sequence is moved to the input sequence and no error is issued.
+   */
+  void commit(std::size_t n)
+  {
+    size_ += (std::min)(n, vector_.size() - size_);
+    vector_.resize(size_);
+  }
 
-/// 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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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);
-}
+  /// Remove characters from the input sequence.
+  /**
+   * Removes @c n characters from the beginning of the input sequence.
+   *
+   * @note If @c n is greater than the size of the input sequence, the entire
+   * input sequence is consumed and no error is issued.
+   */
+  void consume(std::size_t n)
+  {
+    std::size_t consume_length = (std::min)(n, size_);
+    vector_.erase(vector_.begin(), vector_.begin() + consume_length);
+    size_ -= consume_length;
+  }
 
-/// 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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-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);
-}
+private:
+  std::vector<Elem, Allocator>& vector_;
+  std::size_t size_;
+  const std::size_t max_size_;
+};
 
-/// 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.
+/** @defgroup dynamic_buffer asio::dynamic_buffer
  *
- * @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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * @brief The asio::dynamic_buffer function is used to create a
+ * dynamically resized buffer from a @c std::basic_string or @c std::vector.
  */
-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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+/// Create a new dynamic buffer that represents the given string.
+/**
+ * @returns <tt>dynamic_string_buffer<Elem, Traits, Allocator>(data)</tt>.
  */
-inline std::size_t buffer_copy(const mutable_buffers_1& target,
-    const mutable_buffer& source, std::size_t max_bytes_to_copy)
+template <typename Elem, typename Traits, typename Allocator>
+inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+    std::basic_string<Elem, Traits, Allocator>& data) ASIO_NOEXCEPT
 {
-  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+  return dynamic_string_buffer<Elem, Traits, Allocator>(data);
 }
 
-/// Copies a limited number of bytes from a source buffer to a target buffer.
+/// Create a new dynamic buffer that represents the given string.
 /**
- * @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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * @returns <tt>dynamic_string_buffer<Elem, Traits, Allocator>(data,
+ * max_size)</tt>.
  */
-inline std::size_t buffer_copy(const mutable_buffers_1& target,
-    const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
+template <typename Elem, typename Traits, typename Allocator>
+inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+    std::basic_string<Elem, Traits, Allocator>& data,
+    std::size_t max_size) ASIO_NOEXCEPT
 {
-  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+  return dynamic_string_buffer<Elem, Traits, Allocator>(data, max_size);
 }
 
-/// Copies a limited number of bytes from a source buffer sequence to a target
-/// buffer.
+/// Create a new dynamic buffer that represents the given vector.
 /**
- * @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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data)</tt>.
  */
-template <typename ConstBufferSequence>
-inline std::size_t buffer_copy(const mutable_buffers_1& target,
-    const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
+template <typename Elem, typename Allocator>
+inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+    std::vector<Elem, Allocator>& data) ASIO_NOEXCEPT
 {
-  return buffer_copy(buffer(target, max_bytes_to_copy), source);
+  return dynamic_vector_buffer<Elem, Allocator>(data);
 }
 
-/// Copies a limited number of bytes from a source buffer to a target buffer
-/// sequence.
+/// Create a new dynamic buffer that represents the given vector.
 /**
- * @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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data, max_size)</tt>.
  */
-template <typename MutableBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const const_buffer& source, std::size_t max_bytes_to_copy)
+template <typename Elem, typename Allocator>
+inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+    std::vector<Elem, Allocator>& data,
+    std::size_t max_size) ASIO_NOEXCEPT
 {
-  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+  return dynamic_vector_buffer<Elem, Allocator>(data, max_size);
 }
 
-/// 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.
+/*@}*/
+
+/** @defgroup buffer_copy asio::buffer_copy
  *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
+ * @brief The asio::buffer_copy function is used to copy bytes from a
+ * source buffer (or buffer sequence) to a target buffer (or buffer sequence).
  *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
+ * The @c buffer_copy function is available in two forms:
  *
- * @returns The number of bytes copied.
+ * @li A 2-argument form: @c buffer_copy(target, source)
  *
- * @note The number of bytes copied is the lesser of:
+ * @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 max_bytes_to_copy
+ * @li @c If specified, @c max_bytes_to_copy.
  *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
+ * This prevents buffer overflow, regardless of the buffer sizes used in the
+ * copy operation.
+ *
+ * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
+ * consequently it cannot be used to copy between overlapping memory regions.
  */
-template <typename MutableBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const const_buffers_1& source, std::size_t max_bytes_to_copy)
+/*@{*/
+
+namespace detail {
+
+inline std::size_t buffer_copy_1(const mutable_buffer& target,
+    const const_buffer& source)
 {
-  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+  using namespace std; // For memcpy.
+  std::size_t target_size = target.size();
+  std::size_t source_size = source.size();
+  std::size_t n = target_size < source_size ? target_size : source_size;
+  if (n > 0)
+    memcpy(target.data(), source.data(), n);
+  return n;
 }
 
-/// 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
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-template <typename MutableBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const mutable_buffer& source, std::size_t max_bytes_to_copy)
+template <typename TargetIterator, typename SourceIterator>
+inline std::size_t buffer_copy(one_buffer, one_buffer,
+    TargetIterator target_begin, TargetIterator,
+    SourceIterator source_begin, SourceIterator) ASIO_NOEXCEPT
+{
+  return (buffer_copy_1)(*target_begin, *source_begin);
+}
+
+template <typename TargetIterator, typename SourceIterator>
+inline std::size_t buffer_copy(one_buffer, one_buffer,
+    TargetIterator target_begin, TargetIterator,
+    SourceIterator source_begin, SourceIterator,
+    std::size_t max_bytes_to_copy) ASIO_NOEXCEPT
+{
+  return (buffer_copy_1)(*target_begin,
+      asio::buffer(*source_begin, max_bytes_to_copy));
+}
+
+template <typename TargetIterator, typename SourceIterator>
+std::size_t buffer_copy(one_buffer, multiple_buffers,
+    TargetIterator target_begin, TargetIterator,
+    SourceIterator source_begin, SourceIterator source_end,
+    std::size_t max_bytes_to_copy
+      = (std::numeric_limits<std::size_t>::max)()) ASIO_NOEXCEPT
+{
+  std::size_t total_bytes_copied = 0;
+  SourceIterator source_iter = source_begin;
+
+  for (mutable_buffer target_buffer(
+        asio::buffer(*target_begin, max_bytes_to_copy));
+      target_buffer.size() && source_iter != source_end; ++source_iter)
+  {
+    const_buffer source_buffer(*source_iter);
+    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
+    total_bytes_copied += bytes_copied;
+    target_buffer += bytes_copied;
+  }
+
+  return total_bytes_copied;
+}
+
+template <typename TargetIterator, typename SourceIterator>
+std::size_t buffer_copy(multiple_buffers, one_buffer,
+    TargetIterator target_begin, TargetIterator target_end,
+    SourceIterator source_begin, SourceIterator,
+    std::size_t max_bytes_to_copy
+      = (std::numeric_limits<std::size_t>::max)()) ASIO_NOEXCEPT
+{
+  std::size_t total_bytes_copied = 0;
+  TargetIterator target_iter = target_begin;
+
+  for (const_buffer source_buffer(
+        asio::buffer(*source_begin, max_bytes_to_copy));
+      source_buffer.size() && target_iter != target_end; ++target_iter)
+  {
+    mutable_buffer target_buffer(*target_iter);
+    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
+    total_bytes_copied += bytes_copied;
+    source_buffer += bytes_copied;
+  }
+
+  return total_bytes_copied;
+}
+
+template <typename TargetIterator, typename SourceIterator>
+std::size_t buffer_copy(multiple_buffers, multiple_buffers,
+    TargetIterator target_begin, TargetIterator target_end,
+    SourceIterator source_begin, SourceIterator source_end) ASIO_NOEXCEPT
+{
+  std::size_t total_bytes_copied = 0;
+
+  TargetIterator target_iter = target_begin;
+  std::size_t target_buffer_offset = 0;
+
+  SourceIterator source_iter = source_begin;
+  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_1)(target_buffer, source_buffer);
+    total_bytes_copied += bytes_copied;
+
+    if (bytes_copied == target_buffer.size())
+    {
+      ++target_iter;
+      target_buffer_offset = 0;
+    }
+    else
+      target_buffer_offset += bytes_copied;
+
+    if (bytes_copied == source_buffer.size())
+    {
+      ++source_iter;
+      source_buffer_offset = 0;
+    }
+    else
+      source_buffer_offset += bytes_copied;
+  }
+
+  return total_bytes_copied;
+}
+
+template <typename TargetIterator, typename SourceIterator>
+std::size_t buffer_copy(multiple_buffers, multiple_buffers,
+    TargetIterator target_begin, TargetIterator target_end,
+    SourceIterator source_begin, SourceIterator source_end,
+    std::size_t max_bytes_to_copy) ASIO_NOEXCEPT
 {
-  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+  std::size_t total_bytes_copied = 0;
+
+  TargetIterator target_iter = target_begin;
+  std::size_t target_buffer_offset = 0;
+
+  SourceIterator source_iter = source_begin;
+  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_1)(
+        target_buffer, asio::buffer(source_buffer,
+          max_bytes_to_copy - total_bytes_copied));
+    total_bytes_copied += bytes_copied;
+
+    if (bytes_copied == target_buffer.size())
+    {
+      ++target_iter;
+      target_buffer_offset = 0;
+    }
+    else
+      target_buffer_offset += bytes_copied;
+
+    if (bytes_copied == source_buffer.size())
+    {
+      ++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
-/// sequence.
+} // namespace detail
+
+/// 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 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.
+ * @param source A non-modifiable buffer sequence representing the memory
+ * regions from which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
@@ -2147,16 +2099,20 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @li @c buffer_size(source)
  *
- * @li @c max_bytes_to_copy
- *
  * This function is implemented in terms of @c memcpy, and consequently it
  * cannot be used to copy between overlapping memory regions.
  */
-template <typename MutableBufferSequence>
+template <typename MutableBufferSequence, typename ConstBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
+    const ConstBufferSequence& source) ASIO_NOEXCEPT
 {
-  return buffer_copy(target, buffer(source, max_bytes_to_copy));
+  return detail::buffer_copy(
+      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
+      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
+      asio::buffer_sequence_begin(target),
+      asio::buffer_sequence_end(target),
+      asio::buffer_sequence_begin(source),
+      asio::buffer_sequence_end(source));
 }
 
 /// Copies a limited number of bytes from a source buffer sequence to a target
@@ -2184,50 +2140,17 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  * cannot be used to copy between overlapping memory regions.
  */
 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;
+inline std::size_t buffer_copy(const MutableBufferSequence& target,
+    const ConstBufferSequence& source,
+    std::size_t max_bytes_to_copy) ASIO_NOEXCEPT
+{
+  return detail::buffer_copy(
+      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
+      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
+      asio::buffer_sequence_begin(target),
+      asio::buffer_sequence_end(target),
+      asio::buffer_sequence_begin(source),
+      asio::buffer_sequence_end(source), max_bytes_to_copy);
 }
 
 /*@}*/
diff --git a/extern/include/asio/buffered_read_stream.hpp b/extern/include/asio/buffered_read_stream.hpp
index 1c64fb04..c3e7f0b5 100644
--- a/extern/include/asio/buffered_read_stream.hpp
+++ b/extern/include/asio/buffered_read_stream.hpp
@@ -2,7 +2,7 @@
 // buffered_read_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -26,7 +26,7 @@
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -55,6 +55,9 @@ class buffered_read_stream
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
+  /// The type of the executor associated with the object.
+  typedef typename lowest_layer_type::executor_type executor_type;
+
 #if defined(GENERATING_DOCUMENTATION)
   /// The default buffer size.
   static const std::size_t default_buffer_size = implementation_defined;
@@ -96,11 +99,27 @@ class buffered_read_stream
     return next_layer_.lowest_layer();
   }
 
-  /// Get the io_service associated with the object.
-  asio::io_service& get_io_service()
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return next_layer_.lowest_layer().get_executor();
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_context()
+  {
+    return next_layer_.get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_service()
   {
     return next_layer_.get_io_service();
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Close the stream.
   void close()
@@ -109,9 +128,10 @@ class buffered_read_stream
   }
 
   /// Close the stream.
-  asio::error_code close(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return next_layer_.close(ec);
+    next_layer_.close(ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Write the given data to the stream. Returns the number of bytes written.
@@ -139,15 +159,8 @@ class buffered_read_stream
   async_write_some(const ConstBufferSequence& buffers,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
+    return next_layer_.async_write_some(buffers,
         ASIO_MOVE_CAST(WriteHandler)(handler));
-
-    next_layer_.async_write_some(buffers,
-        ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(WriteHandler,
-            void (asio::error_code, std::size_t)))(init.handler));
-
-    return init.result.get();
   }
 
   /// Fill the buffer with some data. Returns the number of bytes placed in the
diff --git a/extern/include/asio/buffered_read_stream_fwd.hpp b/extern/include/asio/buffered_read_stream_fwd.hpp
index 58664c91..334b88a5 100644
--- a/extern/include/asio/buffered_read_stream_fwd.hpp
+++ b/extern/include/asio/buffered_read_stream_fwd.hpp
@@ -2,7 +2,7 @@
 // buffered_read_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/buffered_stream.hpp b/extern/include/asio/buffered_stream.hpp
index 6a35da91..8014fa4d 100644
--- a/extern/include/asio/buffered_stream.hpp
+++ b/extern/include/asio/buffered_stream.hpp
@@ -2,7 +2,7 @@
 // buffered_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,7 +23,7 @@
 #include "asio/buffered_stream_fwd.hpp"
 #include "asio/detail/noncopyable.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -52,6 +52,9 @@ class buffered_stream
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
+  /// The type of the executor associated with the object.
+  typedef typename lowest_layer_type::executor_type executor_type;
+
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_stream(Arg& a)
@@ -87,11 +90,27 @@ class buffered_stream
     return stream_impl_.lowest_layer();
   }
 
-  /// Get the io_service associated with the object.
-  asio::io_service& get_io_service()
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return stream_impl_.lowest_layer().get_executor();
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_context()
+  {
+    return stream_impl_.get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_service()
   {
     return stream_impl_.get_io_service();
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Close the stream.
   void close()
@@ -100,9 +119,10 @@ class buffered_stream
   }
 
   /// Close the stream.
-  asio::error_code close(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return stream_impl_.close(ec);
+    stream_impl_.close(ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Flush all data from the buffer to the next layer. Returns the number of
diff --git a/extern/include/asio/buffered_stream_fwd.hpp b/extern/include/asio/buffered_stream_fwd.hpp
index 1bad0a8a..3492979d 100644
--- a/extern/include/asio/buffered_stream_fwd.hpp
+++ b/extern/include/asio/buffered_stream_fwd.hpp
@@ -2,7 +2,7 @@
 // buffered_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/buffered_write_stream.hpp b/extern/include/asio/buffered_write_stream.hpp
index efc9d939..aac33d38 100644
--- a/extern/include/asio/buffered_write_stream.hpp
+++ b/extern/include/asio/buffered_write_stream.hpp
@@ -2,7 +2,7 @@
 // buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,7 +25,7 @@
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/write.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -55,6 +55,9 @@ class buffered_write_stream
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
+  /// The type of the executor associated with the object.
+  typedef typename lowest_layer_type::executor_type executor_type;
+
 #if defined(GENERATING_DOCUMENTATION)
   /// The default buffer size.
   static const std::size_t default_buffer_size = implementation_defined;
@@ -96,11 +99,27 @@ class buffered_write_stream
     return next_layer_.lowest_layer();
   }
 
-  /// Get the io_service associated with the object.
-  asio::io_service& get_io_service()
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return next_layer_.lowest_layer().get_executor();
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_context()
+  {
+    return next_layer_.get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_service()
   {
     return next_layer_.get_io_service();
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Close the stream.
   void close()
@@ -109,9 +128,10 @@ class buffered_write_stream
   }
 
   /// Close the stream.
-  asio::error_code close(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return next_layer_.close(ec);
+    next_layer_.close(ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Flush all data from the buffer to the next layer. Returns the number of
@@ -174,15 +194,8 @@ class buffered_write_stream
   async_read_some(const MutableBufferSequence& buffers,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
+    return next_layer_.async_read_some(buffers,
         ASIO_MOVE_CAST(ReadHandler)(handler));
-
-    next_layer_.async_read_some(buffers,
-        ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(ReadHandler,
-            void (asio::error_code, std::size_t)))(init.handler));
-
-    return init.result.get();
   }
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read.
diff --git a/extern/include/asio/buffered_write_stream_fwd.hpp b/extern/include/asio/buffered_write_stream_fwd.hpp
index 027382dd..6ef54ba0 100644
--- a/extern/include/asio/buffered_write_stream_fwd.hpp
+++ b/extern/include/asio/buffered_write_stream_fwd.hpp
@@ -2,7 +2,7 @@
 // buffered_write_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/buffers_iterator.hpp b/extern/include/asio/buffers_iterator.hpp
index 0404b12b..f5c9d4c3 100644
--- a/extern/include/asio/buffers_iterator.hpp
+++ b/extern/include/asio/buffers_iterator.hpp
@@ -2,7 +2,7 @@
 // buffers_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -65,7 +65,44 @@ namespace detail
     typedef buffers_iterator_types_helper<is_mutable> helper;
     typedef typename helper::buffer_type buffer_type;
     typedef typename helper::template byte_type<ByteType>::type byte_type;
+    typedef typename BufferSequence::const_iterator const_iterator;
   };
+
+  template <typename ByteType>
+  struct buffers_iterator_types<mutable_buffer, ByteType>
+  {
+    typedef mutable_buffer buffer_type;
+    typedef ByteType byte_type;
+    typedef const mutable_buffer* const_iterator;
+  };
+
+  template <typename ByteType>
+  struct buffers_iterator_types<const_buffer, ByteType>
+  {
+    typedef const_buffer buffer_type;
+    typedef typename add_const<ByteType>::type byte_type;
+    typedef const const_buffer* const_iterator;
+  };
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+  template <typename ByteType>
+  struct buffers_iterator_types<mutable_buffers_1, ByteType>
+  {
+    typedef mutable_buffer buffer_type;
+    typedef ByteType byte_type;
+    typedef const mutable_buffer* const_iterator;
+  };
+
+  template <typename ByteType>
+  struct buffers_iterator_types<const_buffers_1, ByteType>
+  {
+    typedef const_buffer buffer_type;
+    typedef typename add_const<ByteType>::type byte_type;
+    typedef const const_buffer* const_iterator;
+  };
+
+#endif // !defined(ASIO_NO_DEPRECATED)
 }
 
 /// A random access iterator over the bytes in a buffer sequence.
@@ -76,6 +113,9 @@ class buffers_iterator
   typedef typename detail::buffers_iterator_types<
       BufferSequence, ByteType>::buffer_type buffer_type;
 
+  typedef typename detail::buffers_iterator_types<BufferSequence,
+          ByteType>::const_iterator buffer_sequence_iterator_type;
+
 public:
   /// The type used for the distance between two iterators.
   typedef std::ptrdiff_t difference_type;
@@ -130,13 +170,13 @@ class buffers_iterator
 #endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
   {
     buffers_iterator new_iter;
-    new_iter.begin_ = buffers.begin();
-    new_iter.current_ = buffers.begin();
-    new_iter.end_ = buffers.end();
+    new_iter.begin_ = asio::buffer_sequence_begin(buffers);
+    new_iter.current_ = asio::buffer_sequence_begin(buffers);
+    new_iter.end_ = asio::buffer_sequence_end(buffers);
     while (new_iter.current_ != new_iter.end_)
     {
       new_iter.current_buffer_ = *new_iter.current_;
-      if (asio::buffer_size(new_iter.current_buffer_) > 0)
+      if (new_iter.current_buffer_.size() > 0)
         break;
       ++new_iter.current_;
     }
@@ -150,13 +190,13 @@ class buffers_iterator
 #endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
   {
     buffers_iterator new_iter;
-    new_iter.begin_ = buffers.begin();
-    new_iter.current_ = buffers.begin();
-    new_iter.end_ = buffers.end();
+    new_iter.begin_ = asio::buffer_sequence_begin(buffers);
+    new_iter.current_ = asio::buffer_sequence_begin(buffers);
+    new_iter.end_ = asio::buffer_sequence_end(buffers);
     while (new_iter.current_ != new_iter.end_)
     {
       buffer_type buffer = *new_iter.current_;
-      new_iter.position_ += asio::buffer_size(buffer);
+      new_iter.position_ += buffer.size();
       ++new_iter.current_;
     }
     return new_iter;
@@ -300,7 +340,8 @@ class buffers_iterator
   // Dereference the iterator.
   reference dereference() const
   {
-    return buffer_cast<pointer>(current_buffer_)[current_buffer_position_];
+    return static_cast<pointer>(
+        current_buffer_.data())[current_buffer_position_];
   }
 
   // Compare two iterators for equality.
@@ -317,7 +358,7 @@ class buffers_iterator
 
     // Check if the increment can be satisfied by the current buffer.
     ++current_buffer_position_;
-    if (current_buffer_position_ != asio::buffer_size(current_buffer_))
+    if (current_buffer_position_ != current_buffer_.size())
       return;
 
     // Find the next non-empty buffer.
@@ -326,7 +367,7 @@ class buffers_iterator
     while (current_ != end_)
     {
       current_buffer_ = *current_;
-      if (asio::buffer_size(current_buffer_) > 0)
+      if (current_buffer_.size() > 0)
         return;
       ++current_;
     }
@@ -346,12 +387,12 @@ class buffers_iterator
     }
 
     // Find the previous non-empty buffer.
-    typename BufferSequence::const_iterator iter = current_;
+    buffer_sequence_iterator_type iter = current_;
     while (iter != begin_)
     {
       --iter;
       buffer_type buffer = *iter;
-      std::size_t buffer_size = asio::buffer_size(buffer);
+      std::size_t buffer_size = buffer.size();
       if (buffer_size > 0)
       {
         current_ = iter;
@@ -371,8 +412,7 @@ class buffers_iterator
       for (;;)
       {
         std::ptrdiff_t current_buffer_balance
-          = asio::buffer_size(current_buffer_)
-          - current_buffer_position_;
+          = current_buffer_.size() - current_buffer_position_;
 
         // Check if the advance can be satisfied by the current buffer.
         if (current_buffer_balance > n)
@@ -426,12 +466,12 @@ class buffers_iterator
         }
 
         // Find the previous non-empty buffer.
-        typename BufferSequence::const_iterator iter = current_;
+        buffer_sequence_iterator_type iter = current_;
         while (iter != begin_)
         {
           --iter;
           buffer_type buffer = *iter;
-          std::size_t buffer_size = asio::buffer_size(buffer);
+          std::size_t buffer_size = buffer.size();
           if (buffer_size > 0)
           {
             current_ = iter;
@@ -452,9 +492,9 @@ class buffers_iterator
 
   buffer_type current_buffer_;
   std::size_t current_buffer_position_;
-  typename BufferSequence::const_iterator begin_;
-  typename BufferSequence::const_iterator current_;
-  typename BufferSequence::const_iterator end_;
+  buffer_sequence_iterator_type begin_;
+  buffer_sequence_iterator_type current_;
+  buffer_sequence_iterator_type end_;
   std::size_t position_;
 };
 
diff --git a/extern/include/asio/completion_condition.hpp b/extern/include/asio/completion_condition.hpp
index b17b44ae..563f417d 100644
--- a/extern/include/asio/completion_condition.hpp
+++ b/extern/include/asio/completion_condition.hpp
@@ -2,7 +2,7 @@
 // completion_condition.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/connect.hpp b/extern/include/asio/connect.hpp
index 14f29b1e..487ce3e0 100644
--- a/extern/include/asio/connect.hpp
+++ b/extern/include/asio/connect.hpp
@@ -2,7 +2,7 @@
 // connect.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,12 +18,43 @@
 #include "asio/detail/config.hpp"
 #include "asio/async_result.hpp"
 #include "asio/basic_socket.hpp"
+#include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 
+namespace detail
+{
+  char (&has_iterator_helper(...))[2];
+
+  template <typename T>
+  char has_iterator_helper(T*, typename T::iterator* = 0);
+
+  template <typename T>
+  struct has_iterator_typedef
+  {
+    enum { value = (sizeof((has_iterator_helper)((T*)(0))) == 1) };
+  };
+} // namespace detail
+
+/// Type trait used to determine whether a type is an endpoint sequence that can
+/// be used with with @c connect and @c async_connect.
+template <typename T>
+struct is_endpoint_sequence
+{
+#if defined(GENERATING_DOCUMENTATION)
+  /// The value member is true if the type may be used as an endpoint sequence.
+  static const bool value;
+#else
+  enum
+  {
+    value = detail::has_iterator_typedef<T>::value
+  };
+#endif
+};
+
 /**
  * @defgroup connect asio::connect
  *
@@ -41,27 +72,26 @@ namespace asio {
  * @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 endpoints A sequence of endpoints.
  *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
+ * @returns The successfully connected endpoint.
  *
  * @throws asio::system_error Thrown on failure. If the sequence is
  * empty, the associated @c error_code is 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 asio::ip::tcp::resolver::iterator.
- *
  * @par Example
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
+ * tcp::socket s(io_context);
  * asio::connect(s, r.resolve(q)); @endcode
  */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
+template <typename Protocol ASIO_SVC_TPARAM, typename EndpointSequence>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type* = 0);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -73,23 +103,19 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
  * @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 endpoints A sequence of endpoints.
  *
  * @param ec Set to indicate what error occurred, if any. If the sequence is
  * empty, set to 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 asio::ip::tcp::resolver::iterator.
+ * @returns On success, the successfully connected endpoint. Otherwise, a
+ * default-constructed endpoint.
  *
  * @par Example
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
+ * tcp::socket s(io_context);
  * asio::error_code ec;
  * asio::connect(s, r.resolve(q), ec);
  * if (ec)
@@ -97,11 +123,16 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
  *   // An error occurred.
  * } @endcode
  */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, asio::error_code& ec);
+template <typename Protocol ASIO_SVC_TPARAM, typename EndpointSequence>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, asio::error_code& ec,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type* = 0);
 
-/// Establishes a socket connection by trying each endpoint in a sequence.
+#if !defined(ASIO_NO_DEPRECATED)
+/// (Deprecated.) 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
@@ -113,24 +144,80 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  *
  * @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 asio::system_error Thrown on failure. If the sequence is
+ * empty, the associated @c error_code is 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 asio::ip::tcp::resolver::iterator.
+ */
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s, Iterator begin,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+
+/// (Deprecated.) 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 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 asio::ip::tcp::resolver::iterator.
+ */
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    Iterator begin, asio::error_code& ec,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+/// 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 An iterator denoting the successfully connected endpoint.
+ *
  * @throws asio::system_error Thrown on failure. If the sequence is
  * empty, the associated @c error_code is asio::error::not_found.
  * Otherwise, contains the error from the last connection attempt.
  *
  * @par Example
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
- * asio::connect(s, i, end); @endcode
+ * tcp::resolver::results_type e = r.resolve(q);
+ * tcp::socket s(io_context);
+ * asio::connect(s, e.begin(), e.end()); @endcode
  */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
@@ -155,19 +242,19 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  * endpoint. Otherwise, the end iterator.
  *
  * @par Example
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
+ * tcp::resolver::results_type e = r.resolve(q);
+ * tcp::socket s(io_context);
  * asio::error_code ec;
- * asio::connect(s, i, end, ec);
+ * asio::connect(s, e.begin(), e.end(), ec);
  * if (ec)
  * {
  *   // An error occurred.
  * } @endcode
  */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, asio::error_code& ec);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
@@ -180,59 +267,54 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  * @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 endpoints 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(
+ * @code bool connect_condition(
  *     const asio::error_code& ec,
- *     Iterator next); @endcode
+ *     const typename Protocol::endpoint& 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.
+ * indicate success. The @c next parameter is the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
  *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
+ * @returns The successfully connected endpoint.
  *
  * @throws asio::system_error Thrown on failure. If the sequence is
  * empty, the associated @c error_code is 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 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()(
+ *   bool operator()(
  *       const asio::error_code& ec,
- *       Iterator next)
+ *       const::tcp::endpoint& next)
  *   {
  *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
+ *     std::cout << "Trying: " << next << std::endl;
+ *     return true;
  *   }
  * }; @endcode
  * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- * tcp::resolver::iterator i = asio::connect(
- *     s, r.resolve(q), my_connect_condition());
- * std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
+ * tcp::socket s(io_context);
+ * tcp::endpoint e = asio::connect(s,
+ *     r.resolve(q), my_connect_condition());
+ * std::cout << "Connected to: " << e << std::endl; @endcode
  */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ConnectCondition connect_condition);
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type* = 0);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -244,67 +326,148 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  * @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 endpoints 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(
+ * @code bool connect_condition(
  *     const asio::error_code& ec,
- *     Iterator next); @endcode
+ *     const typename Protocol::endpoint& 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.
+ * indicate success. The @c next parameter is the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
  *
  * @param ec Set to indicate what error occurred, if any. If the sequence is
  * empty, set to 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 asio::ip::tcp::resolver::iterator.
+ * @returns On success, the successfully connected endpoint. Otherwise, a
+ * default-constructed endpoint.
  *
  * @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()(
+ *   bool operator()(
  *       const asio::error_code& ec,
- *       Iterator next)
+ *       const::tcp::endpoint& next)
  *   {
  *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
+ *     std::cout << "Trying: " << next << std::endl;
+ *     return true;
  *   }
  * }; @endcode
  * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
+ * tcp::socket s(io_context);
  * asio::error_code ec;
- * tcp::resolver::iterator i = asio::connect(
- *     s, r.resolve(q), my_connect_condition(), ec);
+ * tcp::endpoint e = asio::connect(s,
+ *     r.resolve(q), my_connect_condition(), ec);
  * if (ec)
  * {
  *   // An error occurred.
  * }
  * else
  * {
- *   std::cout << "Connected to: " << i->endpoint() << std::endl;
+ *   std::cout << "Connected to: " << e << std::endl;
  * } @endcode
  */
-template <typename Protocol, typename SocketService,
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    asio::error_code& ec,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type* = 0);
+
+#if !defined(ASIO_NO_DEPRECATED)
+/// (Deprecated.) 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 bool connect_condition(
+ *     const asio::error_code& ec,
+ *     const typename Protocol::endpoint& 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 the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
+ *
+ * @returns On success, an iterator denoting the successfully connected
+ * endpoint. Otherwise, the end iterator.
+ *
+ * @throws asio::system_error Thrown on failure. If the sequence is
+ * empty, the associated @c error_code is 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 asio::ip::tcp::resolver::iterator.
+ */
+template <typename Protocol ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
-    ConnectCondition connect_condition, asio::error_code& ec);
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    Iterator begin, ConnectCondition connect_condition,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+
+/// (Deprecated.) 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 bool connect_condition(
+ *     const asio::error_code& ec,
+ *     const typename Protocol::endpoint& 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 the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
+ *
+ * @param ec Set to indicate what error occurred, if any. If the sequence is
+ * empty, set to 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 asio::ip::tcp::resolver::iterator.
+ */
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s, Iterator begin,
+    ConnectCondition connect_condition, asio::error_code& ec,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -322,19 +485,16 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  *
  * @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(
+ * @code bool connect_condition(
  *     const asio::error_code& ec,
- *     Iterator next); @endcode
+ *     const typename Protocol::endpoint& 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.
+ * indicate success. The @c next parameter is the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
  *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
+ * @returns An iterator denoting the successfully connected endpoint.
  *
  * @throws asio::system_error Thrown on failure. If the sequence is
  * empty, the associated @c error_code is asio::error::not_found.
@@ -345,27 +505,27 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  * information about the individual connection attempts:
  * @code struct my_connect_condition
  * {
- *   template <typename Iterator>
- *   Iterator operator()(
+ *   bool operator()(
  *       const asio::error_code& ec,
- *       Iterator next)
+ *       const::tcp::endpoint& next)
  *   {
  *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
+ *     std::cout << "Trying: " << next << std::endl;
+ *     return true;
  *   }
  * }; @endcode
  * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
- * i = asio::connect(s, i, end, my_connect_condition());
+ * tcp::resolver::results_type e = r.resolve(q);
+ * tcp::socket s(io_context);
+ * tcp::resolver::results_type::iterator i = asio::connect(
+ *     s, e.begin(), e.end(), my_connect_condition());
  * std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
  */
-template <typename Protocol, typename SocketService,
+template <typename Protocol ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s, Iterator begin,
     Iterator end, ConnectCondition connect_condition);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
@@ -384,16 +544,14 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  *
  * @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(
+ * @code bool connect_condition(
  *     const asio::error_code& ec,
- *     Iterator next); @endcode
+ *     const typename Protocol::endpoint& 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.
+ * indicate success. The @c next parameter is the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
  *
  * @param ec Set to indicate what error occurred, if any. If the sequence is
  * empty, set to asio::error::not_found. Otherwise, contains the error
@@ -407,23 +565,23 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  * information about the individual connection attempts:
  * @code struct my_connect_condition
  * {
- *   template <typename Iterator>
- *   Iterator operator()(
+ *   bool operator()(
  *       const asio::error_code& ec,
- *       Iterator next)
+ *       const::tcp::endpoint& next)
  *   {
  *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
+ *     std::cout << "Trying: " << next << std::endl;
+ *     return true;
  *   }
  * }; @endcode
  * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
+ * tcp::resolver::results_type e = r.resolve(q);
+ * tcp::socket s(io_context);
  * asio::error_code ec;
- * i = asio::connect(s, i, end, my_connect_condition(), ec);
+ * tcp::resolver::results_type::iterator i = asio::connect(
+ *     s, e.begin(), e.end(), my_connect_condition());
  * if (ec)
  * {
  *   // An error occurred.
@@ -433,9 +591,9 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  *   std::cout << "Connected to: " << i->endpoint() << std::endl;
  * } @endcode
  */
-template <typename Protocol, typename SocketService,
+template <typename Protocol ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
     asio::error_code& ec);
 
@@ -460,7 +618,7 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  * @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 endpoints 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
@@ -471,23 +629,19 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  *   // error from the last connection attempt.
  *   const asio::error_code& error,
  *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
+ *   // On success, the successfully connected endpoint.
+ *   // Otherwise, a default-constructed endpoint.
+ *   const typename Protocol::endpoint& endpoint
  * ); @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
- * 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 asio::ip::tcp::resolver::iterator.
+ * asio::io_context::post().
  *
  * @par Example
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
+ * tcp::socket s(io_context);
  *
  * // ...
  *
@@ -497,11 +651,11 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  *
  * void resolve_handler(
  *     const asio::error_code& ec,
- *     tcp::resolver::iterator i)
+ *     tcp::resolver::results_type results)
  * {
  *   if (!ec)
  *   {
- *     asio::async_connect(s, i, connect_handler);
+ *     asio::async_connect(s, results, connect_handler);
  *   }
  * }
  *
@@ -509,17 +663,65 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  *
  * void connect_handler(
  *     const asio::error_code& ec,
- *     tcp::resolver::iterator i)
+ *     const tcp::endpoint& endpoint)
  * {
  *   // ...
  * } @endcode
  */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename RangeConnectHandler>
+ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+    void (asio::error_code, typename Protocol::endpoint))
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints,
+    ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type* = 0);
+
+#if !defined(ASIO_NO_DEPRECATED)
+/// (Deprecated.) 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
+ *   // asio::error::not_found. Otherwise, contains the
+ *   // error from the last connection attempt.
+ *   const asio::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
+ * asio::io_context::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 asio::ip::tcp::resolver::iterator.
+ */
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Iterator, typename IteratorConnectHandler>
+ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    Iterator begin, ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
@@ -552,46 +754,31 @@ async_connect(basic_socket<Protocol, SocketService>& s,
  * 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
- * asio::io_service::post().
+ * asio::io_context::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 asio::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (!ec)
- *   {
- *     tcp::resolver::iterator end;
- *     asio::async_connect(s, i, end, connect_handler);
- *   }
- * }
+ * @code std::vector<tcp::endpoint> endpoints = ...;
+ * tcp::socket s(io_context);
+ * asio::async_connect(s,
+ *     endpoints.begin(), endpoints.end(),
+ *     connect_handler);
  *
  * // ...
  *
  * void connect_handler(
  *     const asio::error_code& ec,
- *     tcp::resolver::iterator i)
+ *     std::vector<tcp::endpoint>::iterator i)
  * {
  *   // ...
  * } @endcode
  */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Iterator, typename IteratorConnectHandler>
+ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end,
-    ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+    ASIO_MOVE_ARG(IteratorConnectHandler) handler);
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
@@ -604,20 +791,18 @@ async_connect(basic_socket<Protocol, SocketService>& s,
  * @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 endpoints 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(
+ * @code bool connect_condition(
  *     const asio::error_code& ec,
- *     Iterator next); @endcode
+ *     const typename Protocol::endpoint& 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.
+ * indicate success. The @c next parameter is the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
  *
  * @param handler The handler to be called when the connect operation
  * completes. Copies will be made of the handler as required. The function
@@ -635,31 +820,26 @@ async_connect(basic_socket<Protocol, SocketService>& s,
  * 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
- * 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 asio::ip::tcp::resolver::iterator.
+ * asio::io_context::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()(
+ *   bool operator()(
  *       const asio::error_code& ec,
- *       Iterator next)
+ *       const::tcp::endpoint& next)
  *   {
  *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
+ *     std::cout << "Trying: " << next << std::endl;
+ *     return true;
  *   }
  * }; @endcode
  * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
+ * tcp::socket s(io_context);
  *
  * // ...
  *
@@ -669,11 +849,11 @@ async_connect(basic_socket<Protocol, SocketService>& s,
  *
  * void resolve_handler(
  *     const asio::error_code& ec,
- *     tcp::resolver::iterator i)
+ *     tcp::resolver::results_type results)
  * {
  *   if (!ec)
  *   {
- *     asio::async_connect(s, i,
+ *     asio::async_connect(s, results,
  *         my_connect_condition(),
  *         connect_handler);
  *   }
@@ -683,7 +863,7 @@ async_connect(basic_socket<Protocol, SocketService>& s,
  *
  * void connect_handler(
  *     const asio::error_code& ec,
- *     tcp::resolver::iterator i)
+ *     const tcp::endpoint& endpoint)
  * {
  *   if (ec)
  *   {
@@ -691,17 +871,76 @@ async_connect(basic_socket<Protocol, SocketService>& s,
  *   }
  *   else
  *   {
- *     std::cout << "Connected to: " << i->endpoint() << std::endl;
+ *     std::cout << "Connected to: " << endpoint << std::endl;
  *   }
  * } @endcode
  */
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol ASIO_SVC_TPARAM, typename EndpointSequence,
+    typename ConnectCondition, typename RangeConnectHandler>
+ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+    void (asio::error_code, typename Protocol::endpoint))
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type* = 0);
+
+#if !defined(ASIO_NO_DEPRECATED)
+/// (Deprecated.) 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 bool connect_condition(
+ *     const asio::error_code& ec,
+ *     const typename Protocol::endpoint& 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 the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
+ *
+ * @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
+ *   // asio::error::not_found. Otherwise, contains the
+ *   // error from the last connection attempt.
+ *   const asio::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
+ * asio::io_context::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 asio::ip::tcp::resolver::iterator.
+ */
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+    typename ConnectCondition, typename IteratorConnectHandler>
+ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s, Iterator begin,
     ConnectCondition connect_condition,
-    ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+    ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
@@ -720,16 +959,14 @@ async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  *
  * @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(
+ * @code bool connect_condition(
  *     const asio::error_code& ec,
- *     Iterator next); @endcode
+ *     const typename Protocol::endpoint& 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.
+ * indicate success. The @c next parameter is the next endpoint to be tried.
+ * The function object should return true if the next endpoint should be tried,
+ * and false if it should be skipped.
  *
  * @param handler The handler to be called when the connect operation
  * completes. Copies will be made of the handler as required. The function
@@ -747,27 +984,26 @@ async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  * 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
- * asio::io_service::post().
+ * asio::io_context::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()(
+ *   bool operator()(
  *       const asio::error_code& ec,
- *       Iterator next)
+ *       const::tcp::endpoint& next)
  *   {
  *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
+ *     std::cout << "Trying: " << next << std::endl;
+ *     return true;
  *   }
  * }; @endcode
  * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(io_service);
+ * @code tcp::resolver r(io_context);
  * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
+ * tcp::socket s(io_context);
  *
  * // ...
  *
@@ -804,13 +1040,13 @@ async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  *   }
  * } @endcode
  */
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+    typename ConnectCondition, typename IteratorConnectHandler>
+ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
-    ASIO_MOVE_ARG(ComposedConnectHandler) handler);
+    ASIO_MOVE_ARG(IteratorConnectHandler) handler);
 
 /*@}*/
 
diff --git a/extern/include/asio/coroutine.hpp b/extern/include/asio/coroutine.hpp
index d9dfaaa6..cd2d99e5 100644
--- a/extern/include/asio/coroutine.hpp
+++ b/extern/include/asio/coroutine.hpp
@@ -2,7 +2,7 @@
 // coroutine.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -205,7 +205,7 @@ class coroutine_ref;
  * {
  *   do
  *   {
- *     socket_.reset(new tcp::socket(io_service_));
+ *     socket_.reset(new tcp::socket(io_context_));
  *     yield acceptor->async_accept(*socket_, *this);
  *     fork server(*this)();
  *   } while (is_parent());
@@ -227,7 +227,7 @@ class coroutine_ref;
  * Note that @c fork doesn't do the actual forking by itself. It is the
  * application's responsibility to create a clone of the coroutine and call it.
  * The clone can be called immediately, as above, or scheduled for delayed
- * execution using something like io_service::post().
+ * execution using something like io_context::post().
  *
  * @par Alternate macro names
  *
@@ -289,7 +289,7 @@ class coroutine_ref
       bail_out_of_coroutine: \
       break; \
     } \
-    else case 0:
+    else /* fall-through */ case 0:
 
 #define ASIO_CORO_YIELD_IMPL(n) \
   for (_coro_value = (n);;) \
@@ -301,12 +301,12 @@ class coroutine_ref
     else \
       switch (_coro_value ? 0 : 1) \
         for (;;) \
-          case -1: if (_coro_value) \
+          /* fall-through */ case -1: if (_coro_value) \
             goto terminate_coroutine; \
           else for (;;) \
-            case 1: if (_coro_value) \
+            /* fall-through */ case 1: if (_coro_value) \
               goto bail_out_of_coroutine; \
-            else case 0:
+            else /* fall-through */ case 0:
 
 #define ASIO_CORO_FORK_IMPL(n) \
   for (_coro_value = -(n);; _coro_value = (n)) \
diff --git a/extern/include/asio/datagram_socket_service.hpp b/extern/include/asio/datagram_socket_service.hpp
index a3cc56af..7dc1a3b3 100644
--- a/extern/include/asio/datagram_socket_service.hpp
+++ b/extern/include/asio/datagram_socket_service.hpp
@@ -2,7 +2,7 @@
 // datagram_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include <cstddef>
 #include "asio/async_result.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/null_socket_service.hpp"
@@ -38,7 +41,7 @@ namespace asio {
 template <typename Protocol>
 class datagram_socket_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<datagram_socket_service<Protocol> >
 #endif
@@ -46,7 +49,7 @@ class datagram_socket_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The protocol type.
@@ -73,13 +76,6 @@ class datagram_socket_service
   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;
@@ -87,11 +83,11 @@ class datagram_socket_service
   typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new datagram socket service for the specified io_service.
-  explicit datagram_socket_service(asio::io_service& io_service)
+  /// Construct a new datagram socket service for the specified io_context.
+  explicit datagram_socket_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        datagram_socket_service<Protocol> >(io_service),
-      service_impl_(io_service)
+        datagram_socket_service<Protocol> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -117,17 +113,21 @@ class datagram_socket_service
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
 
+  // All socket services have access to each other's implementations.
+  template <typename Protocol1> friend class datagram_socket_service;
+
   /// Move-construct a new datagram socket implementation from another protocol
   /// type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      datagram_socket_service<Protocol1>& other_service,
       typename datagram_socket_service<
         Protocol1>::implementation_type& other_impl,
       typename enable_if<is_convertible<
         Protocol1, Protocol>::value>::type* = 0)
   {
     service_impl_.template converting_move_construct<Protocol1>(
-        impl, other_impl);
+        impl, other_service.service_impl_, other_impl);
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
@@ -138,22 +138,23 @@ class datagram_socket_service
   }
 
   // Open a new datagram socket implementation.
-  asio::error_code open(implementation_type& impl,
+  ASIO_SYNC_OP_VOID open(implementation_type& impl,
       const protocol_type& protocol, asio::error_code& ec)
   {
     if (protocol.type() == ASIO_OS_DEF(SOCK_DGRAM))
       service_impl_.open(impl, protocol, ec);
     else
       ec = asio::error::invalid_argument;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native socket to a datagram socket.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const protocol_type& protocol, const native_handle_type& native_socket,
       asio::error_code& ec)
   {
-    return service_impl_.assign(impl, protocol, native_socket, ec);
+    service_impl_.assign(impl, protocol, native_socket, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is open.
@@ -163,16 +164,18 @@ class datagram_socket_service
   }
 
   /// Close a datagram socket implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
+  /// Release ownership of the underlying socket.
+  native_handle_type release(implementation_type& impl,
+      asio::error_code& ec)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.release(impl, ec);
   }
 
   /// Get the native socket implementation.
@@ -182,10 +185,11 @@ class datagram_socket_service
   }
 
   /// Cancel all asynchronous operations associated with the socket.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
@@ -203,17 +207,19 @@ class datagram_socket_service
   }
 
   // Bind the datagram socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
+  ASIO_SYNC_OP_VOID bind(implementation_type& impl,
       const endpoint_type& endpoint, asio::error_code& ec)
   {
-    return service_impl_.bind(impl, endpoint, ec);
+    service_impl_.bind(impl, endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Connect the datagram socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
+  ASIO_SYNC_OP_VOID connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, asio::error_code& ec)
   {
-    return service_impl_.connect(impl, peer_endpoint, ec);
+    service_impl_.connect(impl, peer_endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous connect.
@@ -224,37 +230,39 @@ class datagram_socket_service
       const endpoint_type& peer_endpoint,
       ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    detail::async_result_init<
-      ConnectHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(ConnectHandler)(handler));
+    async_completion<ConnectHandler,
+      void (asio::error_code)> init(handler);
 
-    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+    service_impl_.async_connect(impl, peer_endpoint, init.completion_handler);
 
     return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
-  asio::error_code set_option(implementation_type& impl,
+  ASIO_SYNC_OP_VOID set_option(implementation_type& impl,
       const SettableSocketOption& option, asio::error_code& ec)
   {
-    return service_impl_.set_option(impl, option, ec);
+    service_impl_.set_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
-  asio::error_code get_option(const implementation_type& impl,
+  ASIO_SYNC_OP_VOID get_option(const implementation_type& impl,
       GettableSocketOption& option, asio::error_code& ec) const
   {
-    return service_impl_.get_option(impl, option, ec);
+    service_impl_.get_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
-  asio::error_code io_control(implementation_type& impl,
+  ASIO_SYNC_OP_VOID io_control(implementation_type& impl,
       IoControlCommand& command, asio::error_code& ec)
   {
-    return service_impl_.io_control(impl, command, ec);
+    service_impl_.io_control(impl, command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the socket.
@@ -264,10 +272,11 @@ class datagram_socket_service
   }
 
   /// Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.non_blocking(impl, mode, ec);
+    service_impl_.non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native socket implementation.
@@ -277,10 +286,11 @@ class datagram_socket_service
   }
 
   /// Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID native_non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.native_non_blocking(impl, mode, ec);
+    service_impl_.native_non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the local endpoint.
@@ -298,10 +308,36 @@ class datagram_socket_service
   }
 
   /// Disable sends or receives on the socket.
-  asio::error_code shutdown(implementation_type& impl,
+  ASIO_SYNC_OP_VOID shutdown(implementation_type& impl,
       socket_base::shutdown_type what, asio::error_code& ec)
   {
-    return service_impl_.shutdown(impl, what, ec);
+    service_impl_.shutdown(impl, what, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the socket to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  ASIO_SYNC_OP_VOID wait(implementation_type& impl,
+      socket_base::wait_type w, asio::error_code& ec)
+  {
+    service_impl_.wait(impl, w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the socket to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(implementation_type& impl, socket_base::wait_type w,
+      ASIO_MOVE_ARG(WaitHandler) handler)
+  {
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    service_impl_.async_wait(impl, w, init.completion_handler);
+
+    return init.result.get();
   }
 
   /// Send the given data to the peer.
@@ -321,11 +357,10 @@ class datagram_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_send(impl, buffers, flags, init.handler);
+    service_impl_.async_send(impl, buffers, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -348,12 +383,11 @@ class datagram_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     service_impl_.async_send_to(impl, buffers,
-        destination, flags, init.handler);
+        destination, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -376,11 +410,10 @@ class datagram_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_receive(impl, buffers, flags, init.handler);
+    service_impl_.async_receive(impl, buffers, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -404,21 +437,20 @@ class datagram_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     service_impl_.async_receive_from(impl, buffers,
-        sender_endpoint, flags, init.handler);
+        sender_endpoint, flags, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -429,4 +461,6 @@ class datagram_socket_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_DATAGRAM_SOCKET_SERVICE_HPP
diff --git a/extern/include/asio/deadline_timer.hpp b/extern/include/asio/deadline_timer.hpp
index 8bf22ce0..5a215547 100644
--- a/extern/include/asio/deadline_timer.hpp
+++ b/extern/include/asio/deadline_timer.hpp
@@ -2,7 +2,7 @@
 // deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/deadline_timer_service.hpp b/extern/include/asio/deadline_timer_service.hpp
index 96ead3b4..2dcc83e2 100644
--- a/extern/include/asio/deadline_timer_service.hpp
+++ b/extern/include/asio/deadline_timer_service.hpp
@@ -2,7 +2,7 @@
 // deadline_timer_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,15 +17,16 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_BOOST_DATE_TIME) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
 #include "asio/async_result.hpp"
 #include "asio/detail/deadline_timer_service.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/time_traits.hpp"
-#include "asio/detail/timer_queue_ptime.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -36,7 +37,7 @@ template <typename TimeType,
     typename TimeTraits = asio::time_traits<TimeType> >
 class deadline_timer_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<
       deadline_timer_service<TimeType, TimeTraits> >
@@ -45,7 +46,7 @@ class deadline_timer_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The time traits type.
@@ -69,11 +70,11 @@ class deadline_timer_service
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// Construct a new timer service for the specified io_service.
-  explicit deadline_timer_service(asio::io_service& io_service)
+  /// Construct a new timer service for the specified io_context.
+  explicit deadline_timer_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        deadline_timer_service<TimeType, TimeTraits> >(io_service),
-      service_impl_(io_service)
+        deadline_timer_service<TimeType, TimeTraits> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -105,7 +106,7 @@ class deadline_timer_service
   /// Get the expiry time for the timer as an absolute time.
   time_type expires_at(const implementation_type& impl) const
   {
-    return service_impl_.expires_at(impl);
+    return service_impl_.expiry(impl);
   }
 
   /// Set the expiry time for the timer as an absolute time.
@@ -118,14 +119,14 @@ class deadline_timer_service
   /// Get the expiry time for the timer relative to now.
   duration_type expires_from_now(const implementation_type& impl) const
   {
-    return service_impl_.expires_from_now(impl);
+    return TimeTraits::subtract(service_impl_.expiry(impl), TimeTraits::now());
   }
 
   /// Set the expiry time for the timer relative to now.
   std::size_t expires_from_now(implementation_type& impl,
       const duration_type& expiry_time, asio::error_code& ec)
   {
-    return service_impl_.expires_from_now(impl, expiry_time, ec);
+    return service_impl_.expires_after(impl, expiry_time, ec);
   }
 
   // Perform a blocking wait on the timer.
@@ -141,20 +142,19 @@ class deadline_timer_service
   async_wait(implementation_type& impl,
       ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    detail::async_result_init<
-      WaitHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(WaitHandler)(handler));
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
 
-    service_impl_.async_wait(impl, init.handler);
+    service_impl_.async_wait(impl, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -168,4 +168,6 @@ class deadline_timer_service
 #endif // defined(ASIO_HAS_BOOST_DATE_TIME)
        // || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_DEADLINE_TIMER_SERVICE_HPP
diff --git a/extern/include/asio/defer.hpp b/extern/include/asio/defer.hpp
new file mode 100644
index 00000000..a0897f2f
--- /dev/null
+++ b/extern/include/asio/defer.hpp
@@ -0,0 +1,107 @@
+//
+// defer.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DEFER_HPP
+#define ASIO_DEFER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/async_result.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/is_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// Submits a completion token or function object for execution.
+/**
+ * This function submits an object for execution using the object's associated
+ * executor. The function object is queued for execution, and is never called
+ * from the current thread prior to returning from <tt>defer()</tt>.
+ *
+ * This function has the following effects:
+ *
+ * @li Constructs a function object handler of type @c Handler, initialized
+ * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ *
+ * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
+ * initializing the object as <tt>result(handler)</tt>.
+ *
+ * @li Obtains the handler's associated executor object @c ex by performing
+ * <tt>get_associated_executor(handler)</tt>.
+ *
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * <tt>get_associated_allocator(handler)</tt>.
+ *
+ * @li Performs <tt>ex.defer(std::move(handler), alloc)</tt>.
+ *
+ * @li Returns <tt>result.get()</tt>.
+ */
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
+    ASIO_MOVE_ARG(CompletionToken) token);
+
+/// Submits a completion token or function object for execution.
+/**
+ * This function submits an object for execution using the specified executor.
+ * The function object is queued for execution, and is never called from the
+ * current thread prior to returning from <tt>defer()</tt>.
+ *
+ * This function has the following effects:
+ *
+ * @li Constructs a function object handler of type @c Handler, initialized
+ * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ *
+ * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
+ * initializing the object as <tt>result(handler)</tt>.
+ *
+ * @li Obtains the handler's associated executor object @c ex1 by performing
+ * <tt>get_associated_executor(handler)</tt>.
+ *
+ * @li Creates a work object @c w by performing <tt>make_work(ex1)</tt>.
+ *
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * <tt>get_associated_allocator(handler)</tt>.
+ *
+ * @li Constructs a function object @c f with a function call operator that
+ * performs <tt>ex1.dispatch(std::move(handler), alloc)</tt> followed by
+ * <tt>w.reset()</tt>.
+ *
+ * @li Performs <tt>Executor(ex).defer(std::move(f), alloc)</tt>.
+ *
+ * @li Returns <tt>result.get()</tt>.
+ */
+template <typename Executor, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
+    const Executor& ex, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_executor<Executor>::value>::type* = 0);
+
+/// Submits a completion token or function object for execution.
+/**
+ * @returns <tt>defer(ctx.get_executor(), forward<CompletionToken>(token))</tt>.
+ */
+template <typename ExecutionContext, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
+    ExecutionContext& ctx, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type* = 0);
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/defer.hpp"
+
+#endif // ASIO_DEFER_HPP
diff --git a/extern/include/asio/detail/addressof.hpp b/extern/include/asio/detail/addressof.hpp
deleted file mode 100644
index 82bea544..00000000
--- a/extern/include/asio/detail/addressof.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// detail/addressof.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_ADDRESSOF_HPP
-#define ASIO_DETAIL_ADDRESSOF_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_STD_ADDRESSOF)
-# include <memory>
-#else // defined(ASIO_HAS_STD_ADDRESSOF)
-# include <boost/utility/addressof.hpp>
-#endif // defined(ASIO_HAS_STD_ADDRESSOF)
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_ADDRESSOF)
-using std::addressof;
-#else // defined(ASIO_HAS_STD_ADDRESSOF)
-using boost::addressof;
-#endif // defined(ASIO_HAS_STD_ADDRESSOF)
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_ADDRESSOF_HPP
diff --git a/extern/include/asio/detail/array.hpp b/extern/include/asio/detail/array.hpp
index 125f84d1..ba429746 100644
--- a/extern/include/asio/detail/array.hpp
+++ b/extern/include/asio/detail/array.hpp
@@ -2,7 +2,7 @@
 // detail/array.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/array_fwd.hpp b/extern/include/asio/detail/array_fwd.hpp
index b53eca3a..4161db0d 100644
--- a/extern/include/asio/detail/array_fwd.hpp
+++ b/extern/include/asio/detail/array_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/array_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/assert.hpp b/extern/include/asio/detail/assert.hpp
index 104c0d11..a952a441 100644
--- a/extern/include/asio/detail/assert.hpp
+++ b/extern/include/asio/detail/assert.hpp
@@ -2,7 +2,7 @@
 // detail/assert.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/atomic_count.hpp b/extern/include/asio/detail/atomic_count.hpp
index 5956da01..2bf75a53 100644
--- a/extern/include/asio/detail/atomic_count.hpp
+++ b/extern/include/asio/detail/atomic_count.hpp
@@ -2,7 +2,7 @@
 // detail/atomic_count.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/base_from_completion_cond.hpp b/extern/include/asio/detail/base_from_completion_cond.hpp
index a1aa61e8..73b4a957 100644
--- a/extern/include/asio/detail/base_from_completion_cond.hpp
+++ b/extern/include/asio/detail/base_from_completion_cond.hpp
@@ -2,7 +2,7 @@
 // detail/base_from_completion_cond.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/bind_handler.hpp b/extern/include/asio/detail/bind_handler.hpp
index 1cce775b..0f4f066d 100644
--- a/extern/include/asio/detail/bind_handler.hpp
+++ b/extern/include/asio/detail/bind_handler.hpp
@@ -2,7 +2,7 @@
 // detail/bind_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,9 +16,12 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/type_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -29,8 +32,9 @@ template <typename Handler, typename Arg1>
 class binder1
 {
 public:
-  binder1(const Handler& handler, const Arg1& arg1)
-    : handler_(handler),
+  template <typename T>
+  binder1(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1)
+    : handler_(ASIO_MOVE_CAST(T)(handler)),
       arg1_(arg1)
   {
   }
@@ -41,6 +45,20 @@ class binder1
   {
   }
 
+#if defined(ASIO_HAS_MOVE)
+  binder1(const binder1& other)
+    : handler_(other.handler_),
+      arg1_(other.arg1_)
+  {
+  }
+
+  binder1(binder1&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(other.arg1_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_));
@@ -97,18 +115,21 @@ inline void asio_handler_invoke(const Function& function,
 }
 
 template <typename Handler, typename Arg1>
-inline binder1<Handler, Arg1> bind_handler(Handler handler,
-    const Arg1& arg1)
+inline binder1<typename decay<Handler>::type, Arg1> bind_handler(
+    ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1)
 {
-  return binder1<Handler, Arg1>(handler, arg1);
+  return binder1<typename decay<Handler>::type, Arg1>(0,
+      ASIO_MOVE_CAST(Handler)(handler), arg1);
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
 class binder2
 {
 public:
-  binder2(const Handler& handler, const Arg1& arg1, const Arg2& arg2)
-    : handler_(handler),
+  template <typename T>
+  binder2(int, ASIO_MOVE_ARG(T) handler,
+      const Arg1& arg1, const Arg2& arg2)
+    : handler_(ASIO_MOVE_CAST(T)(handler)),
       arg1_(arg1),
       arg2_(arg2)
   {
@@ -121,6 +142,22 @@ class binder2
   {
   }
 
+#if defined(ASIO_HAS_MOVE)
+  binder2(const binder2& other)
+    : handler_(other.handler_),
+      arg1_(other.arg1_),
+      arg2_(other.arg2_)
+  {
+  }
+
+  binder2(binder2&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(other.arg1_)),
+      arg2_(ASIO_MOVE_CAST(Arg2)(other.arg2_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
@@ -179,27 +216,29 @@ inline void asio_handler_invoke(const Function& function,
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
-inline binder2<Handler, Arg1, Arg2> bind_handler(Handler handler,
-    const Arg1& arg1, const Arg2& arg2)
+inline binder2<typename decay<Handler>::type, Arg1, Arg2> bind_handler(
+    ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2)
 {
-  return binder2<Handler, Arg1, Arg2>(handler, arg1, arg2);
+  return binder2<typename decay<Handler>::type, Arg1, Arg2>(0,
+      ASIO_MOVE_CAST(Handler)(handler), arg1, arg2);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 class binder3
 {
 public:
-  binder3(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3)
-    : handler_(handler),
+  template <typename T>
+  binder3(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
+      const Arg2& arg2, const Arg3& arg3)
+    : handler_(ASIO_MOVE_CAST(T)(handler)),
       arg1_(arg1),
       arg2_(arg2),
       arg3_(arg3)
   {
   }
 
-  binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3)
+  binder3(Handler& handler, const Arg1& arg1,
+      const Arg2& arg2, const Arg3& arg3)
     : handler_(ASIO_MOVE_CAST(Handler)(handler)),
       arg1_(arg1),
       arg2_(arg2),
@@ -207,11 +246,28 @@ class binder3
   {
   }
 
+#if defined(ASIO_HAS_MOVE)
+  binder3(const binder3& other)
+    : handler_(other.handler_),
+      arg1_(other.arg1_),
+      arg2_(other.arg2_),
+      arg3_(other.arg3_)
+  {
+  }
+
+  binder3(binder3&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(other.arg1_)),
+      arg2_(ASIO_MOVE_CAST(Arg2)(other.arg2_)),
+      arg3_(ASIO_MOVE_CAST(Arg3)(other.arg3_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_));
+        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_));
   }
 
   void operator()() const
@@ -250,8 +306,8 @@ inline bool asio_handler_is_continuation(
       this_handler->handler_);
 }
 
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3>
+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)
 {
@@ -259,8 +315,8 @@ inline void asio_handler_invoke(Function& function,
       function, this_handler->handler_);
 }
 
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3>
+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)
 {
@@ -269,20 +325,23 @@ 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(Handler handler,
-    const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
+inline binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3> bind_handler(
+    ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2,
+    const Arg3& arg3)
 {
-  return binder3<Handler, Arg1, Arg2, Arg3>(handler, arg1, arg2, arg3);
+  return binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3>(0,
+      ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
+template <typename Handler, typename Arg1,
+    typename Arg2, typename Arg3, typename Arg4>
 class binder4
 {
 public:
-  binder4(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4)
-    : handler_(handler),
+  template <typename T>
+  binder4(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
+      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
+    : handler_(ASIO_MOVE_CAST(T)(handler)),
       arg1_(arg1),
       arg2_(arg2),
       arg3_(arg3),
@@ -290,8 +349,8 @@ class binder4
   {
   }
 
-  binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4)
+  binder4(Handler& handler, const Arg1& arg1,
+      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
     : handler_(ASIO_MOVE_CAST(Handler)(handler)),
       arg1_(arg1),
       arg2_(arg2),
@@ -300,11 +359,30 @@ class binder4
   {
   }
 
+#if defined(ASIO_HAS_MOVE)
+  binder4(const binder4& other)
+    : handler_(other.handler_),
+      arg1_(other.arg1_),
+      arg2_(other.arg2_),
+      arg3_(other.arg3_),
+      arg4_(other.arg4_)
+  {
+  }
+
+  binder4(binder4&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(other.arg1_)),
+      arg2_(ASIO_MOVE_CAST(Arg2)(other.arg2_)),
+      arg3_(ASIO_MOVE_CAST(Arg3)(other.arg3_)),
+      arg4_(ASIO_MOVE_CAST(Arg4)(other.arg4_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_),
+        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
         static_cast<const Arg4&>(arg4_));
   }
 
@@ -321,8 +399,8 @@ class binder4
   Arg4 arg4_;
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
+template <typename Handler, typename Arg1,
+    typename Arg2, typename Arg3, typename Arg4>
 inline void* asio_handler_allocate(std::size_t size,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
@@ -330,8 +408,8 @@ inline void* asio_handler_allocate(std::size_t size,
       size, this_handler->handler_);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
+template <typename Handler, typename Arg1,
+    typename Arg2, typename Arg3, typename Arg4>
 inline void asio_handler_deallocate(void* pointer, std::size_t size,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
@@ -339,8 +417,8 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
       pointer, size, this_handler->handler_);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
+template <typename Handler, typename Arg1,
+    typename Arg2, typename Arg3, typename Arg4>
 inline bool asio_handler_is_continuation(
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
@@ -348,8 +426,8 @@ inline bool asio_handler_is_continuation(
       this_handler->handler_);
 }
 
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4>
+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)
 {
@@ -357,8 +435,8 @@ inline void asio_handler_invoke(Function& function,
       function, this_handler->handler_);
 }
 
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4>
+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)
 {
@@ -366,24 +444,25 @@ inline void asio_handler_invoke(const Function& function,
       function, this_handler->handler_);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
-inline binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
-    Handler handler, const Arg1& arg1, const Arg2& arg2,
-    const Arg3& arg3, const Arg4& arg4)
+template <typename Handler, typename Arg1,
+    typename Arg2, typename Arg3, typename Arg4>
+inline binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>
+bind_handler(ASIO_MOVE_ARG(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,
-      arg4);
+  return binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>(0,
+      ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3, arg4);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
+template <typename Handler, typename Arg1, typename Arg2,
+    typename Arg3, typename Arg4, typename Arg5>
 class binder5
 {
 public:
-  binder5(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
-    : handler_(handler),
+  template <typename T>
+  binder5(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
+      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
+    : handler_(ASIO_MOVE_CAST(T)(handler)),
       arg1_(arg1),
       arg2_(arg2),
       arg3_(arg3),
@@ -403,13 +482,33 @@ class binder5
   {
   }
 
+#if defined(ASIO_HAS_MOVE)
+  binder5(const binder5& other)
+    : handler_(other.handler_),
+      arg1_(other.arg1_),
+      arg2_(other.arg2_),
+      arg3_(other.arg3_),
+      arg4_(other.arg4_),
+      arg5_(other.arg5_)
+  {
+  }
+
+  binder5(binder5&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(other.arg1_)),
+      arg2_(ASIO_MOVE_CAST(Arg2)(other.arg2_)),
+      arg3_(ASIO_MOVE_CAST(Arg3)(other.arg3_)),
+      arg4_(ASIO_MOVE_CAST(Arg4)(other.arg4_)),
+      arg5_(ASIO_MOVE_CAST(Arg5)(other.arg5_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_),
-        static_cast<const Arg4&>(arg4_),
-        static_cast<const Arg5&>(arg5_));
+        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
+        static_cast<const Arg4&>(arg4_), static_cast<const Arg5&>(arg5_));
   }
 
   void operator()() const
@@ -426,8 +525,8 @@ class binder5
   Arg5 arg5_;
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
+template <typename Handler, typename Arg1, typename Arg2,
+    typename Arg3, typename Arg4, typename Arg5>
 inline void* asio_handler_allocate(std::size_t size,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
@@ -435,8 +534,8 @@ inline void* asio_handler_allocate(std::size_t size,
       size, this_handler->handler_);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
+template <typename Handler, typename Arg1, typename Arg2,
+    typename Arg3, typename Arg4, typename Arg5>
 inline void asio_handler_deallocate(void* pointer, std::size_t size,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
@@ -444,8 +543,8 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
       pointer, size, this_handler->handler_);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
+template <typename Handler, typename Arg1, typename Arg2,
+    typename Arg3, typename Arg4, typename Arg5>
 inline bool asio_handler_is_continuation(
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
@@ -453,8 +552,8 @@ inline bool asio_handler_is_continuation(
       this_handler->handler_);
 }
 
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4, typename Arg5>
+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)
 {
@@ -462,8 +561,8 @@ inline void asio_handler_invoke(Function& function,
       function, this_handler->handler_);
 }
 
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4, typename Arg5>
+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)
 {
@@ -471,17 +570,245 @@ inline void asio_handler_invoke(const Function& function,
       function, this_handler->handler_);
 }
 
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
-inline binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
-    Handler handler, const Arg1& arg1, const Arg2& arg2,
-    const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
+template <typename Handler, typename Arg1, typename Arg2,
+    typename Arg3, typename Arg4, typename Arg5>
+inline binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>
+bind_handler(ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1,
+    const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
+{
+  return binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>(0,
+      ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3, arg4, arg5);
+}
+
+#if defined(ASIO_HAS_MOVE)
+
+template <typename Handler, typename Arg1>
+class move_binder1
+{
+public:
+  move_binder1(int, ASIO_MOVE_ARG(Handler) handler,
+      ASIO_MOVE_ARG(Arg1) arg1)
+    : handler_(ASIO_MOVE_CAST(Handler)(handler)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(arg1))
+  {
+  }
+
+  move_binder1(move_binder1&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(other.arg1_))
+  {
+  }
+
+  void operator()()
+  {
+    handler_(ASIO_MOVE_CAST(Arg1)(arg1_));
+  }
+
+//private:
+  Handler handler_;
+  Arg1 arg1_;
+};
+
+template <typename Handler, typename Arg1>
+inline void* asio_handler_allocate(std::size_t size,
+    move_binder1<Handler, Arg1>* this_handler)
+{
+  return asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+}
+
+template <typename Handler, typename Arg1>
+inline void asio_handler_deallocate(void* pointer, std::size_t size,
+    move_binder1<Handler, Arg1>* this_handler)
+{
+  asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+}
+
+template <typename Handler, typename Arg1>
+inline bool asio_handler_is_continuation(
+    move_binder1<Handler, Arg1>* this_handler)
+{
+  return asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
+template <typename Function, typename Handler, typename Arg1>
+inline void asio_handler_invoke(ASIO_MOVE_ARG(Function) function,
+    move_binder1<Handler, Arg1>* this_handler)
+{
+  asio_handler_invoke_helpers::invoke(
+      ASIO_MOVE_CAST(Function)(function), this_handler->handler_);
+}
+
+template <typename Handler, typename Arg1, typename Arg2>
+class move_binder2
+{
+public:
+  move_binder2(int, ASIO_MOVE_ARG(Handler) handler,
+      const Arg1& arg1, ASIO_MOVE_ARG(Arg2) arg2)
+    : handler_(ASIO_MOVE_CAST(Handler)(handler)),
+      arg1_(arg1),
+      arg2_(ASIO_MOVE_CAST(Arg2)(arg2))
+  {
+  }
+
+  move_binder2(move_binder2&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      arg1_(ASIO_MOVE_CAST(Arg1)(other.arg1_)),
+      arg2_(ASIO_MOVE_CAST(Arg2)(other.arg2_))
+  {
+  }
+
+  void operator()()
+  {
+    handler_(static_cast<const Arg1&>(arg1_),
+        ASIO_MOVE_CAST(Arg2)(arg2_));
+  }
+
+//private:
+  Handler handler_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+};
+
+template <typename Handler, typename Arg1, typename Arg2>
+inline void* asio_handler_allocate(std::size_t size,
+    move_binder2<Handler, Arg1, Arg2>* this_handler)
+{
+  return asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+}
+
+template <typename Handler, typename Arg1, typename Arg2>
+inline void asio_handler_deallocate(void* pointer, std::size_t size,
+    move_binder2<Handler, Arg1, Arg2>* this_handler)
+{
+  asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+}
+
+template <typename Handler, typename Arg1, typename Arg2>
+inline bool asio_handler_is_continuation(
+    move_binder2<Handler, Arg1, Arg2>* this_handler)
 {
-  return binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>(handler, arg1, arg2,
-      arg3, arg4, arg5);
+  return asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
 }
 
+template <typename Function, typename Handler, typename Arg1, typename Arg2>
+inline void asio_handler_invoke(ASIO_MOVE_ARG(Function) function,
+    move_binder2<Handler, Arg1, Arg2>* this_handler)
+{
+  asio_handler_invoke_helpers::invoke(
+      ASIO_MOVE_CAST(Function)(function), this_handler->handler_);
+}
+
+#endif // defined(ASIO_HAS_MOVE)
+
 } // namespace detail
+
+template <typename Handler, typename Arg1, typename Allocator>
+struct associated_allocator<detail::binder1<Handler, Arg1>, Allocator>
+{
+  typedef typename associated_allocator<Handler, Allocator>::type type;
+
+  static type get(const detail::binder1<Handler, Arg1>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
+struct associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allocator>
+{
+  typedef typename associated_allocator<Handler, Allocator>::type type;
+
+  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Handler, typename Arg1, typename Executor>
+struct associated_executor<detail::binder1<Handler, Arg1>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
+
+  static type get(const detail::binder1<Handler, Arg1>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+  }
+};
+
+template <typename Handler, typename Arg1, typename Arg2, typename Executor>
+struct associated_executor<detail::binder2<Handler, Arg1, Arg2>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
+
+  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#if defined(ASIO_HAS_MOVE)
+
+template <typename Handler, typename Arg1, typename Allocator>
+struct associated_allocator<detail::move_binder1<Handler, Arg1>, Allocator>
+{
+  typedef typename associated_allocator<Handler, Allocator>::type type;
+
+  static type get(const detail::move_binder1<Handler, Arg1>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
+struct associated_allocator<
+    detail::move_binder2<Handler, Arg1, Arg2>, Allocator>
+{
+  typedef typename associated_allocator<Handler, Allocator>::type type;
+
+  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Handler, typename Arg1, typename Executor>
+struct associated_executor<detail::move_binder1<Handler, Arg1>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
+
+  static type get(const detail::move_binder1<Handler, Arg1>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+  }
+};
+
+template <typename Handler, typename Arg1, typename Arg2, typename Executor>
+struct associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
+
+  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // defined(ASIO_HAS_MOVE)
+
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
diff --git a/extern/include/asio/detail/buffer_resize_guard.hpp b/extern/include/asio/detail/buffer_resize_guard.hpp
index 5a33c3f5..58ebc4cc 100644
--- a/extern/include/asio/detail/buffer_resize_guard.hpp
+++ b/extern/include/asio/detail/buffer_resize_guard.hpp
@@ -2,7 +2,7 @@
 // detail/buffer_resize_guard.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/buffer_sequence_adapter.hpp b/extern/include/asio/detail/buffer_sequence_adapter.hpp
index 2f388c6b..92a8e3d2 100644
--- a/extern/include/asio/detail/buffer_sequence_adapter.hpp
+++ b/extern/include/asio/detail/buffer_sequence_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/buffer_sequence_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -27,11 +27,12 @@ namespace detail {
 
 class buffer_sequence_adapter_base
 {
-protected:
 #if defined(ASIO_WINDOWS_RUNTIME)
+public:
   // The maximum number of buffers to support in a single operation.
   enum { max_buffers = 1 };
 
+protected:
   typedef Windows::Storage::Streams::IBuffer^ native_buffer_type;
 
   ASIO_DECL static void init_native_buffer(
@@ -42,28 +43,32 @@ class buffer_sequence_adapter_base
       native_buffer_type& buf,
       const asio::const_buffer& buffer);
 #elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+public:
   // The maximum number of buffers to support in a single operation.
   enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
 
+protected:
   typedef WSABUF native_buffer_type;
 
   static void init_native_buffer(WSABUF& buf,
       const asio::mutable_buffer& buffer)
   {
-    buf.buf = asio::buffer_cast<char*>(buffer);
-    buf.len = static_cast<ULONG>(asio::buffer_size(buffer));
+    buf.buf = static_cast<char*>(buffer.data());
+    buf.len = static_cast<ULONG>(buffer.size());
   }
 
   static void init_native_buffer(WSABUF& buf,
       const asio::const_buffer& buffer)
   {
-    buf.buf = const_cast<char*>(asio::buffer_cast<const char*>(buffer));
-    buf.len = static_cast<ULONG>(asio::buffer_size(buffer));
+    buf.buf = const_cast<char*>(static_cast<const char*>(buffer.data()));
+    buf.len = static_cast<ULONG>(buffer.size());
   }
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+public:
   // The maximum number of buffers to support in a single operation.
   enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
 
+protected:
   typedef iovec native_buffer_type;
 
   static void init_iov_base(void*& base, void* addr)
@@ -80,16 +85,15 @@ class buffer_sequence_adapter_base
   static void init_native_buffer(iovec& iov,
       const asio::mutable_buffer& buffer)
   {
-    init_iov_base(iov.iov_base, asio::buffer_cast<void*>(buffer));
-    iov.iov_len = asio::buffer_size(buffer);
+    init_iov_base(iov.iov_base, buffer.data());
+    iov.iov_len = buffer.size();
   }
 
   static void init_native_buffer(iovec& iov,
       const asio::const_buffer& buffer)
   {
-    init_iov_base(iov.iov_base, const_cast<void*>(
-          asio::buffer_cast<const void*>(buffer)));
-    iov.iov_len = asio::buffer_size(buffer);
+    init_iov_base(iov.iov_base, const_cast<void*>(buffer.data()));
+    iov.iov_len = buffer.size();
   }
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 };
@@ -103,14 +107,9 @@ class buffer_sequence_adapter
   explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
     : count_(0), total_buffer_size_(0)
   {
-    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);
-      init_native_buffer(buffers_[count_], buffer);
-      total_buffer_size_ += asio::buffer_size(buffer);
-    }
+    buffer_sequence_adapter::init(
+        asio::buffer_sequence_begin(buffer_sequence),
+        asio::buffer_sequence_end(buffer_sequence));
   }
 
   native_buffer_type* buffers()
@@ -123,6 +122,11 @@ class buffer_sequence_adapter
     return count_;
   }
 
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -130,45 +134,184 @@ class buffer_sequence_adapter
 
   static bool all_empty(const Buffers& buffer_sequence)
   {
-    typename Buffers::const_iterator iter = buffer_sequence.begin();
-    typename Buffers::const_iterator end = buffer_sequence.end();
+    return buffer_sequence_adapter::all_empty(
+        asio::buffer_sequence_begin(buffer_sequence),
+        asio::buffer_sequence_end(buffer_sequence));
+  }
+
+  static void validate(const Buffers& buffer_sequence)
+  {
+    buffer_sequence_adapter::validate(
+        asio::buffer_sequence_begin(buffer_sequence),
+        asio::buffer_sequence_end(buffer_sequence));
+  }
+
+  static Buffer first(const Buffers& buffer_sequence)
+  {
+    return buffer_sequence_adapter::first(
+        asio::buffer_sequence_begin(buffer_sequence),
+        asio::buffer_sequence_end(buffer_sequence));
+  }
+
+private:
+  template <typename Iterator>
+  void init(Iterator begin, Iterator end)
+  {
+    Iterator iter = begin;
+    for (; iter != end && count_ < max_buffers; ++iter, ++count_)
+    {
+      Buffer buffer(*iter);
+      init_native_buffer(buffers_[count_], buffer);
+      total_buffer_size_ += buffer.size();
+    }
+  }
+
+  template <typename Iterator>
+  static bool all_empty(Iterator begin, Iterator end)
+  {
+    Iterator iter = begin;
     std::size_t i = 0;
     for (; iter != end && i < max_buffers; ++iter, ++i)
-      if (asio::buffer_size(Buffer(*iter)) > 0)
+      if (Buffer(*iter).size() > 0)
         return false;
     return true;
   }
 
-  static void validate(const Buffers& buffer_sequence)
+  template <typename Iterator>
+  static void validate(Iterator begin, Iterator end)
   {
-    typename Buffers::const_iterator iter = buffer_sequence.begin();
-    typename Buffers::const_iterator end = buffer_sequence.end();
+    Iterator iter = begin;
     for (; iter != end; ++iter)
     {
       Buffer buffer(*iter);
-      asio::buffer_cast<const void*>(buffer);
+      buffer.data();
     }
   }
 
-  static Buffer first(const Buffers& buffer_sequence)
+  template <typename Iterator>
+  static Buffer first(Iterator begin, Iterator end)
   {
-    typename Buffers::const_iterator iter = buffer_sequence.begin();
-    typename Buffers::const_iterator end = buffer_sequence.end();
+    Iterator iter = begin;
     for (; iter != end; ++iter)
     {
       Buffer buffer(*iter);
-      if (asio::buffer_size(buffer) != 0)
+      if (buffer.size() != 0)
         return buffer;
     }
     return Buffer();
   }
 
-private:
   native_buffer_type buffers_[max_buffers];
   std::size_t count_;
   std::size_t total_buffer_size_;
 };
 
+template <typename Buffer>
+class buffer_sequence_adapter<Buffer, asio::mutable_buffer>
+  : buffer_sequence_adapter_base
+{
+public:
+  explicit buffer_sequence_adapter(
+      const asio::mutable_buffer& buffer_sequence)
+  {
+    init_native_buffer(buffer_, Buffer(buffer_sequence));
+    total_buffer_size_ = buffer_sequence.size();
+  }
+
+  native_buffer_type* buffers()
+  {
+    return &buffer_;
+  }
+
+  std::size_t count() const
+  {
+    return 1;
+  }
+
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
+  bool all_empty() const
+  {
+    return total_buffer_size_ == 0;
+  }
+
+  static bool all_empty(const asio::mutable_buffer& buffer_sequence)
+  {
+    return buffer_sequence.size() == 0;
+  }
+
+  static void validate(const asio::mutable_buffer& buffer_sequence)
+  {
+    buffer_sequence.data();
+  }
+
+  static Buffer first(const asio::mutable_buffer& buffer_sequence)
+  {
+    return Buffer(buffer_sequence);
+  }
+
+private:
+  native_buffer_type buffer_;
+  std::size_t total_buffer_size_;
+};
+
+template <typename Buffer>
+class buffer_sequence_adapter<Buffer, asio::const_buffer>
+  : buffer_sequence_adapter_base
+{
+public:
+  explicit buffer_sequence_adapter(
+      const asio::const_buffer& buffer_sequence)
+  {
+    init_native_buffer(buffer_, Buffer(buffer_sequence));
+    total_buffer_size_ = buffer_sequence.size();
+  }
+
+  native_buffer_type* buffers()
+  {
+    return &buffer_;
+  }
+
+  std::size_t count() const
+  {
+    return 1;
+  }
+
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
+  bool all_empty() const
+  {
+    return total_buffer_size_ == 0;
+  }
+
+  static bool all_empty(const asio::const_buffer& buffer_sequence)
+  {
+    return buffer_sequence.size() == 0;
+  }
+
+  static void validate(const asio::const_buffer& buffer_sequence)
+  {
+    buffer_sequence.data();
+  }
+
+  static Buffer first(const asio::const_buffer& buffer_sequence)
+  {
+    return Buffer(buffer_sequence);
+  }
+
+private:
+  native_buffer_type buffer_;
+  std::size_t total_buffer_size_;
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
+
 template <typename Buffer>
 class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
   : buffer_sequence_adapter_base
@@ -178,7 +321,7 @@ class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
       const asio::mutable_buffers_1& buffer_sequence)
   {
     init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = asio::buffer_size(buffer_sequence);
+    total_buffer_size_ = buffer_sequence.size();
   }
 
   native_buffer_type* buffers()
@@ -191,6 +334,11 @@ class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
     return 1;
   }
 
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -198,12 +346,12 @@ class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
 
   static bool all_empty(const asio::mutable_buffers_1& buffer_sequence)
   {
-    return asio::buffer_size(buffer_sequence) == 0;
+    return buffer_sequence.size() == 0;
   }
 
   static void validate(const asio::mutable_buffers_1& buffer_sequence)
   {
-    asio::buffer_cast<const void*>(buffer_sequence);
+    buffer_sequence.data();
   }
 
   static Buffer first(const asio::mutable_buffers_1& buffer_sequence)
@@ -225,7 +373,7 @@ class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
       const asio::const_buffers_1& buffer_sequence)
   {
     init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = asio::buffer_size(buffer_sequence);
+    total_buffer_size_ = buffer_sequence.size();
   }
 
   native_buffer_type* buffers()
@@ -238,6 +386,11 @@ class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
     return 1;
   }
 
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -245,12 +398,12 @@ class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
 
   static bool all_empty(const asio::const_buffers_1& buffer_sequence)
   {
-    return asio::buffer_size(buffer_sequence) == 0;
+    return buffer_sequence.size() == 0;
   }
 
   static void validate(const asio::const_buffers_1& buffer_sequence)
   {
-    asio::buffer_cast<const void*>(buffer_sequence);
+    buffer_sequence.data();
   }
 
   static Buffer first(const asio::const_buffers_1& buffer_sequence)
@@ -263,6 +416,8 @@ class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
   std::size_t total_buffer_size_;
 };
 
+#endif // !defined(ASIO_NO_DEPRECATED)
+
 template <typename Buffer, typename Elem>
 class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
   : buffer_sequence_adapter_base
@@ -273,8 +428,7 @@ class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
   {
     init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
     init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
-    total_buffer_size_ = asio::buffer_size(buffer_sequence[0])
-      + asio::buffer_size(buffer_sequence[1]);
+    total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
   }
 
   native_buffer_type* buffers()
@@ -287,6 +441,11 @@ class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
     return 2;
   }
 
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -294,19 +453,18 @@ class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
 
   static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
   {
-    return asio::buffer_size(buffer_sequence[0]) == 0
-      && asio::buffer_size(buffer_sequence[1]) == 0;
+    return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
   }
 
   static void validate(const boost::array<Elem, 2>& buffer_sequence)
   {
-    asio::buffer_cast<const void*>(buffer_sequence[0]);
-    asio::buffer_cast<const void*>(buffer_sequence[1]);
+    buffer_sequence[0].data();
+    buffer_sequence[1].data();
   }
 
   static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
   {
-    return Buffer(asio::buffer_size(buffer_sequence[0]) != 0
+    return Buffer(buffer_sequence[0].size() != 0
         ? buffer_sequence[0] : buffer_sequence[1]);
   }
 
@@ -327,8 +485,7 @@ class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
   {
     init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
     init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
-    total_buffer_size_ = asio::buffer_size(buffer_sequence[0])
-      + asio::buffer_size(buffer_sequence[1]);
+    total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
   }
 
   native_buffer_type* buffers()
@@ -341,6 +498,11 @@ class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
     return 2;
   }
 
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -348,19 +510,18 @@ class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
 
   static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
   {
-    return asio::buffer_size(buffer_sequence[0]) == 0
-      && asio::buffer_size(buffer_sequence[1]) == 0;
+    return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
   }
 
   static void validate(const std::array<Elem, 2>& buffer_sequence)
   {
-    asio::buffer_cast<const void*>(buffer_sequence[0]);
-    asio::buffer_cast<const void*>(buffer_sequence[1]);
+    buffer_sequence[0].data();
+    buffer_sequence[1].data();
   }
 
   static Buffer first(const std::array<Elem, 2>& buffer_sequence)
   {
-    return Buffer(asio::buffer_size(buffer_sequence[0]) != 0
+    return Buffer(buffer_sequence[0].size() != 0
         ? buffer_sequence[0] : buffer_sequence[1]);
   }
 
diff --git a/extern/include/asio/detail/buffered_stream_storage.hpp b/extern/include/asio/detail/buffered_stream_storage.hpp
index 4e6bcd39..c5eb081d 100644
--- a/extern/include/asio/detail/buffered_stream_storage.hpp
+++ b/extern/include/asio/detail/buffered_stream_storage.hpp
@@ -2,7 +2,7 @@
 // detail/buffered_stream_storage.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/call_stack.hpp b/extern/include/asio/detail/call_stack.hpp
index fa763e6b..5725a10a 100644
--- a/extern/include/asio/detail/call_stack.hpp
+++ b/extern/include/asio/detail/call_stack.hpp
@@ -2,7 +2,7 @@
 // detail/call_stack.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,7 +25,7 @@ namespace asio {
 namespace detail {
 
 // Helper class to determine whether or not the current thread is inside an
-// invocation of io_service::run() for a specified io_service object.
+// invocation of io_context::run() for a specified io_context object.
 template <typename Key, typename Value = unsigned char>
 class call_stack
 {
diff --git a/extern/include/asio/detail/chrono.hpp b/extern/include/asio/detail/chrono.hpp
new file mode 100644
index 00000000..8f56beed
--- /dev/null
+++ b/extern/include/asio/detail/chrono.hpp
@@ -0,0 +1,66 @@
+//
+// detail/chrono.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_CHRONO_HPP
+#define ASIO_DETAIL_CHRONO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_STD_CHRONO)
+# include <chrono>
+#elif defined(ASIO_HAS_BOOST_CHRONO)
+# include <boost/chrono/system_clocks.hpp>
+#endif // defined(ASIO_HAS_BOOST_CHRONO)
+
+namespace asio {
+namespace chrono {
+
+#if defined(ASIO_HAS_STD_CHRONO)
+using std::chrono::duration;
+using std::chrono::time_point;
+using std::chrono::duration_cast;
+using std::chrono::nanoseconds;
+using std::chrono::microseconds;
+using std::chrono::milliseconds;
+using std::chrono::seconds;
+using std::chrono::minutes;
+using std::chrono::hours;
+using std::chrono::time_point_cast;
+#if defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
+typedef std::chrono::monotonic_clock steady_clock;
+#else // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
+using std::chrono::steady_clock;
+#endif // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
+using std::chrono::system_clock;
+using std::chrono::high_resolution_clock;
+#elif defined(ASIO_HAS_BOOST_CHRONO)
+using boost::chrono::duration;
+using boost::chrono::time_point;
+using boost::chrono::duration_cast;
+using boost::chrono::nanoseconds;
+using boost::chrono::microseconds;
+using boost::chrono::milliseconds;
+using boost::chrono::seconds;
+using boost::chrono::minutes;
+using boost::chrono::hours;
+using boost::chrono::time_point_cast;
+using boost::chrono::system_clock;
+using boost::chrono::steady_clock;
+using boost::chrono::high_resolution_clock;
+#endif // defined(ASIO_HAS_BOOST_CHRONO)
+
+} // namespace chrono
+} // namespace asio
+
+#endif // ASIO_DETAIL_CHRONO_HPP
diff --git a/extern/include/asio/detail/chrono_time_traits.hpp b/extern/include/asio/detail/chrono_time_traits.hpp
index 525d551f..d1528f70 100644
--- a/extern/include/asio/detail/chrono_time_traits.hpp
+++ b/extern/include/asio/detail/chrono_time_traits.hpp
@@ -2,7 +2,7 @@
 // detail/chrono_time_traits.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/completion_handler.hpp b/extern/include/asio/detail/completion_handler.hpp
index 35ded0fa..58a2e6db 100644
--- a/extern/include/asio/detail/completion_handler.hpp
+++ b/extern/include/asio/detail/completion_handler.hpp
@@ -2,7 +2,7 @@
 // detail/completion_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,11 +15,11 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/config.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -37,17 +37,19 @@ class completion_handler : public operation
     : operation(&completion_handler::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(h))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     completion_handler* h(static_cast<completion_handler*>(base));
     ptr p = { asio::detail::addressof(h->handler_), h, h };
+    handler_work<Handler> w(h->handler_);
 
-    ASIO_HANDLER_COMPLETION((h));
+    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
@@ -64,7 +66,7 @@ class completion_handler : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN(());
-      asio_handler_invoke_helpers::invoke(handler, handler);
+      w.complete(handler, handler);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/concurrency_hint.hpp b/extern/include/asio/detail/concurrency_hint.hpp
new file mode 100644
index 00000000..229124d3
--- /dev/null
+++ b/extern/include/asio/detail/concurrency_hint.hpp
@@ -0,0 +1,94 @@
+//
+// detail/concurrency_hint.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_CONCURRENCY_HINT_HPP
+#define ASIO_DETAIL_CONCURRENCY_HINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/noncopyable.hpp"
+
+// The concurrency hint ID and mask are used to identify when a "well-known"
+// concurrency hint value has been passed to the io_context.
+#define ASIO_CONCURRENCY_HINT_ID 0xA5100000u
+#define ASIO_CONCURRENCY_HINT_ID_MASK 0xFFFF0000u
+
+// If set, this bit indicates that the scheduler should perform locking.
+#define ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER 0x1u
+
+// If set, this bit indicates that the reactor should perform locking when
+// managing descriptor registrations.
+#define ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION 0x2u
+
+// If set, this bit indicates that the reactor should perform locking for I/O.
+#define ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO 0x4u
+
+// Helper macro to determine if we have a special concurrency hint.
+#define ASIO_CONCURRENCY_HINT_IS_SPECIAL(hint) \
+  ((static_cast<unsigned>(hint) \
+    & ASIO_CONCURRENCY_HINT_ID_MASK) \
+      == ASIO_CONCURRENCY_HINT_ID)
+
+// Helper macro to determine if locking is enabled for a given facility.
+#define ASIO_CONCURRENCY_HINT_IS_LOCKING(facility, hint) \
+  (((static_cast<unsigned>(hint) \
+    & (ASIO_CONCURRENCY_HINT_ID_MASK \
+      | ASIO_CONCURRENCY_HINT_LOCKING_ ## facility)) \
+        ^ ASIO_CONCURRENCY_HINT_ID) != 0)
+
+// This special concurrency hint disables locking in both the scheduler and
+// reactor I/O. This hint has the following restrictions:
+//
+// - Care must be taken to ensure that all operations on the io_context and any
+//   of its associated I/O objects (such as sockets and timers) occur in only
+//   one thread at a time.
+//
+// - Asynchronous resolve operations fail with operation_not_supported.
+//
+// - If a signal_set is used with the io_context, signal_set objects cannot be
+//   used with any other io_context in the program.
+#define ASIO_CONCURRENCY_HINT_UNSAFE \
+  static_cast<int>(ASIO_CONCURRENCY_HINT_ID)
+
+// This special concurrency hint disables locking in the reactor I/O. This hint
+// has the following restrictions:
+//
+// - Care must be taken to ensure that run functions on the io_context, and all
+//   operations on the io_context's associated I/O objects (such as sockets and
+//   timers), occur in only one thread at a time.
+#define ASIO_CONCURRENCY_HINT_UNSAFE_IO \
+  static_cast<int>(ASIO_CONCURRENCY_HINT_ID \
+      | ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \
+      | ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION)
+
+// The special concurrency hint provides full thread safety.
+#define ASIO_CONCURRENCY_HINT_SAFE \
+  static_cast<int>(ASIO_CONCURRENCY_HINT_ID \
+      | ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \
+      | ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION \
+      | ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO)
+
+// This #define may be overridden at compile time to specify a program-wide
+// default concurrency hint, used by the zero-argument io_context constructor.
+#if !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
+# define ASIO_CONCURRENCY_HINT_DEFAULT -1
+#endif // !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
+
+// This #define may be overridden at compile time to specify a program-wide
+// concurrency hint, used by the one-argument io_context constructor when
+// passed a value of 1.
+#if !defined(ASIO_CONCURRENCY_HINT_1)
+# define ASIO_CONCURRENCY_HINT_1 1
+#endif // !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
+
+#endif // ASIO_DETAIL_CONCURRENCY_HINT_HPP
diff --git a/extern/include/asio/detail/conditionally_enabled_event.hpp b/extern/include/asio/detail/conditionally_enabled_event.hpp
new file mode 100644
index 00000000..0fda401e
--- /dev/null
+++ b/extern/include/asio/detail/conditionally_enabled_event.hpp
@@ -0,0 +1,112 @@
+//
+// detail/conditionally_enabled_event.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
+#define ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/conditionally_enabled_mutex.hpp"
+#include "asio/detail/event.hpp"
+#include "asio/detail/noncopyable.hpp"
+#include "asio/detail/null_event.hpp"
+#include "asio/detail/scoped_lock.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+// Mutex adapter used to conditionally enable or disable locking.
+class conditionally_enabled_event
+  : private noncopyable
+{
+public:
+  // Constructor.
+  conditionally_enabled_event()
+  {
+  }
+
+  // Destructor.
+  ~conditionally_enabled_event()
+  {
+  }
+
+  // Signal the event. (Retained for backward compatibility.)
+  void signal(conditionally_enabled_mutex::scoped_lock& lock)
+  {
+    if (lock.mutex_.enabled_)
+      event_.signal(lock);
+  }
+
+  // Signal all waiters.
+  void signal_all(conditionally_enabled_mutex::scoped_lock& lock)
+  {
+    if (lock.mutex_.enabled_)
+      event_.signal_all(lock);
+  }
+
+  // Unlock the mutex and signal one waiter.
+  void unlock_and_signal_one(
+      conditionally_enabled_mutex::scoped_lock& lock)
+  {
+    if (lock.mutex_.enabled_)
+      event_.unlock_and_signal_one(lock);
+  }
+
+  // If there's a waiter, unlock the mutex and signal it.
+  bool maybe_unlock_and_signal_one(
+      conditionally_enabled_mutex::scoped_lock& lock)
+  {
+    if (lock.mutex_.enabled_)
+      return event_.maybe_unlock_and_signal_one(lock);
+    else
+      return false;
+  }
+
+  // Reset the event.
+  void clear(conditionally_enabled_mutex::scoped_lock& lock)
+  {
+    if (lock.mutex_.enabled_)
+      event_.clear(lock);
+  }
+
+  // Wait for the event to become signalled.
+  void wait(conditionally_enabled_mutex::scoped_lock& lock)
+  {
+    if (lock.mutex_.enabled_)
+      event_.wait(lock);
+    else
+      null_event().wait(lock);
+  }
+
+  // Timed wait for the event to become signalled.
+  bool wait_for_usec(
+      conditionally_enabled_mutex::scoped_lock& lock, long usec)
+  {
+    if (lock.mutex_.enabled_)
+      return event_.wait_for_usec(lock, usec);
+    else
+      return null_event().wait_for_usec(lock, usec);
+  }
+
+private:
+  asio::detail::event event_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
diff --git a/extern/include/asio/detail/conditionally_enabled_mutex.hpp b/extern/include/asio/detail/conditionally_enabled_mutex.hpp
new file mode 100644
index 00000000..2872db98
--- /dev/null
+++ b/extern/include/asio/detail/conditionally_enabled_mutex.hpp
@@ -0,0 +1,149 @@
+//
+// detail/conditionally_enabled_mutex.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
+#define ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/mutex.hpp"
+#include "asio/detail/noncopyable.hpp"
+#include "asio/detail/scoped_lock.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+// Mutex adapter used to conditionally enable or disable locking.
+class conditionally_enabled_mutex
+  : private noncopyable
+{
+public:
+  // Helper class to lock and unlock a mutex automatically.
+  class scoped_lock
+    : private noncopyable
+  {
+  public:
+    // Tag type used to distinguish constructors.
+    enum adopt_lock_t { adopt_lock };
+
+    // Constructor adopts a lock that is already held.
+    scoped_lock(conditionally_enabled_mutex& m, adopt_lock_t)
+      : mutex_(m),
+        locked_(m.enabled_)
+    {
+    }
+
+    // Constructor acquires the lock.
+    explicit scoped_lock(conditionally_enabled_mutex& m)
+      : mutex_(m)
+    {
+      if (m.enabled_)
+      {
+        mutex_.mutex_.lock();
+        locked_ = true;
+      }
+      else
+        locked_ = false;
+    }
+
+    // Destructor releases the lock.
+    ~scoped_lock()
+    {
+      if (locked_)
+        mutex_.mutex_.unlock();
+    }
+
+    // Explicitly acquire the lock.
+    void lock()
+    {
+      if (mutex_.enabled_ && !locked_)
+      {
+        mutex_.mutex_.lock();
+        locked_ = true;
+      }
+    }
+
+    // Explicitly release the lock.
+    void unlock()
+    {
+      if (locked_)
+      {
+        mutex_.unlock();
+        locked_ = false;
+      }
+    }
+
+    // Test whether the lock is held.
+    bool locked() const
+    {
+      return locked_;
+    }
+
+    // Get the underlying mutex.
+    asio::detail::mutex& mutex()
+    {
+      return mutex_.mutex_;
+    }
+
+  private:
+    friend class conditionally_enabled_event;
+    conditionally_enabled_mutex& mutex_;
+    bool locked_;
+  };
+
+  // Constructor.
+  explicit conditionally_enabled_mutex(bool enabled)
+    : enabled_(enabled)
+  {
+  }
+
+  // Destructor.
+  ~conditionally_enabled_mutex()
+  {
+  }
+
+  // Determine whether locking is enabled.
+  bool enabled() const
+  {
+    return enabled_;
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+    if (enabled_)
+      mutex_.lock();
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+    if (enabled_)
+      mutex_.unlock();
+  }
+
+private:
+  friend class scoped_lock;
+  friend class conditionally_enabled_event;
+  asio::detail::mutex mutex_;
+  const bool enabled_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
diff --git a/extern/include/asio/detail/config.hpp b/extern/include/asio/detail/config.hpp
index 9d7bd526..cde334e8 100644
--- a/extern/include/asio/detail/config.hpp
+++ b/extern/include/asio/detail/config.hpp
@@ -2,7 +2,7 @@
 // detail/config.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -65,9 +65,13 @@
 #if !defined(ASIO_MSVC)
 # if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
 #  define ASIO_MSVC BOOST_MSVC
-# elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__)
+# elif defined(_MSC_VER) && (defined(__INTELLISENSE__) \
+      || (!defined(__MWERKS__) && !defined(__EDG_VERSION__)))
 #  define ASIO_MSVC _MSC_VER
 # endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
+#endif // !defined(ASIO_MSVC)
+#if defined(ASIO_MSVC)
+# include <ciso646> // Needed for _HAS_CXX17.
 #endif // defined(ASIO_MSVC)
 
 // Clang / libc++ detection.
@@ -82,6 +86,11 @@
 # endif // (__cplusplus >= 201103)
 #endif // defined(__clang__)
 
+// Android platform detection.
+#if defined(__ANDROID__)
+# include <android/api-level.h>
+#endif // defined(__ANDROID__)
+
 // Support move construction and assignment on compilers known to allow it.
 #if !defined(ASIO_HAS_MOVE)
 # if !defined(ASIO_DISABLE_MOVE)
@@ -110,6 +119,7 @@
 // references and perfect forwarding.
 #if defined(ASIO_HAS_MOVE) && !defined(ASIO_MOVE_CAST)
 # define ASIO_MOVE_ARG(type) type&&
+# define ASIO_MOVE_ARG2(type1, type2) type1, type2&&
 # define ASIO_MOVE_CAST(type) static_cast<type&&>
 # define ASIO_MOVE_CAST2(type1, type2) static_cast<type1, type2&&>
 #endif // defined(ASIO_HAS_MOVE) && !defined(ASIO_MOVE_CAST)
@@ -154,9 +164,38 @@
 #    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
 #   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
 #  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1900)
+#    define ASIO_HAS_VARIADIC_TEMPLATES 1
+#   endif // (_MSC_VER >= 1900)
+#  endif // defined(ASIO_MSVC)
 # endif // !defined(ASIO_DISABLE_VARIADIC_TEMPLATES)
 #endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
 
+// Support deleted functions on compilers known to allow it.
+#if !defined(ASIO_DELETED)
+# if defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define ASIO_DELETED = delete
+#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+# endif // defined(__GNUC__)
+# if defined(__clang__)
+#  if __has_feature(__cxx_deleted_functions__)
+#   define ASIO_DELETED = delete
+#  endif // __has_feature(__cxx_deleted_functions__)
+# endif // defined(__clang__)
+# if defined(ASIO_MSVC)
+#  if (_MSC_VER >= 1900)
+#   define ASIO_DELETED = delete
+#  endif // (_MSC_VER >= 1900)
+# endif // defined(ASIO_MSVC)
+# if !defined(ASIO_DELETED)
+#  define ASIO_DELETED
+# endif // !defined(ASIO_DELETED)
+#endif // !defined(ASIO_DELETED)
+
 // Support constexpr on compilers known to allow it.
 #if !defined(ASIO_HAS_CONSTEXPR)
 # if !defined(ASIO_DISABLE_CONSTEXPR)
@@ -172,6 +211,11 @@
 #    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
 #   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
 #  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1900)
+#    define ASIO_HAS_CONSTEXPR 1
+#   endif // (_MSC_VER >= 1900)
+#  endif // defined(ASIO_MSVC)
 # endif // !defined(ASIO_DISABLE_CONSTEXPR)
 #endif // !defined(ASIO_HAS_CONSTEXPR)
 #if !defined(ASIO_CONSTEXPR)
@@ -182,6 +226,85 @@
 # endif // defined(ASIO_HAS_CONSTEXPR)
 #endif // !defined(ASIO_CONSTEXPR)
 
+// Support noexcept on compilers known to allow it.
+#if !defined(ASIO_NOEXCEPT)
+# if !defined(ASIO_DISABLE_NOEXCEPT)
+#  if (BOOST_VERSION >= 105300)
+#   define ASIO_NOEXCEPT BOOST_NOEXCEPT
+#   define ASIO_NOEXCEPT_OR_NOTHROW BOOST_NOEXCEPT_OR_NOTHROW
+#  elif defined(__clang__)
+#   if __has_feature(__cxx_noexcept__)
+#    define ASIO_NOEXCEPT noexcept(true)
+#    define ASIO_NOEXCEPT_OR_NOTHROW noexcept(true)
+#   endif // __has_feature(__cxx_noexcept__)
+#  elif defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#      define ASIO_NOEXCEPT noexcept(true)
+#      define ASIO_NOEXCEPT_OR_NOTHROW noexcept(true)
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#  elif defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1900)
+#    define ASIO_NOEXCEPT noexcept(true)
+#    define ASIO_NOEXCEPT_OR_NOTHROW noexcept(true)
+#   endif // (_MSC_VER >= 1900)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_NOEXCEPT)
+# if !defined(ASIO_NOEXCEPT)
+#  define ASIO_NOEXCEPT
+# endif // !defined(ASIO_NOEXCEPT)
+# if !defined(ASIO_NOEXCEPT_OR_NOTHROW)
+#  define ASIO_NOEXCEPT_OR_NOTHROW throw()
+# endif // !defined(ASIO_NOEXCEPT_OR_NOTHROW)
+#endif // !defined(ASIO_NOEXCEPT)
+
+// Support automatic type deduction on compilers known to support it.
+#if !defined(ASIO_HAS_DECLTYPE)
+# if !defined(ASIO_DISABLE_DECLTYPE)
+#  if defined(__clang__)
+#   if __has_feature(__cxx_decltype__)
+#    define ASIO_HAS_DECLTYPE 1
+#   endif // __has_feature(__cxx_decltype__)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define ASIO_HAS_DECLTYPE 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define ASIO_HAS_DECLTYPE 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_DECLTYPE)
+#endif // !defined(ASIO_HAS_DECLTYPE)
+
+// Support alias templates on compilers known to allow it.
+#if !defined(ASIO_HAS_ALIAS_TEMPLATES)
+# if !defined(ASIO_DISABLE_ALIAS_TEMPLATES)
+#  if defined(__clang__)
+#   if __has_feature(__cxx_alias_templates__)
+#    define ASIO_HAS_ALIAS_TEMPLATES 1
+#   endif // __has_feature(__cxx_alias_templates__)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define ASIO_HAS_ALIAS_TEMPLATES 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1900)
+#    define ASIO_HAS_ALIAS_TEMPLATES 1
+#   endif // (_MSC_VER >= 1900)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_ALIAS_TEMPLATES)
+#endif // !defined(ASIO_HAS_ALIAS_TEMPLATES)
+
 // Standard library support for system errors.
 #if !defined(ASIO_HAS_STD_SYSTEM_ERROR)
 # if !defined(ASIO_DISABLE_STD_SYSTEM_ERROR)
@@ -223,8 +346,7 @@
 #     define ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true)
 #   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-# if defined(ASIO_MSVC)
+# elif defined(ASIO_MSVC)
 #  if (_MSC_VER >= 1900)
 #   define ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true)
 #  endif // (_MSC_VER >= 1900)
@@ -286,6 +408,31 @@
 # endif // !defined(ASIO_DISABLE_STD_SHARED_PTR)
 #endif // !defined(ASIO_HAS_STD_SHARED_PTR)
 
+// Standard library support for allocator_arg_t.
+#if !defined(ASIO_HAS_STD_ALLOCATOR_ARG)
+# if !defined(ASIO_DISABLE_STD_ALLOCATOR_ARG)
+#  if defined(__clang__)
+#   if defined(ASIO_HAS_CLANG_LIBCXX)
+#    define ASIO_HAS_STD_ALLOCATOR_ARG 1
+#   elif (__cplusplus >= 201103)
+#    define ASIO_HAS_STD_ALLOCATOR_ARG 1
+#   endif // (__cplusplus >= 201103)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define ASIO_HAS_STD_ALLOCATOR_ARG 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1600)
+#    define ASIO_HAS_STD_ALLOCATOR_ARG 1
+#   endif // (_MSC_VER >= 1600)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_STD_ALLOCATOR_ARG)
+#endif // !defined(ASIO_HAS_STD_ALLOCATOR_ARG)
+
 // Standard library support for atomic operations.
 #if !defined(ASIO_HAS_STD_ATOMIC)
 # if !defined(ASIO_DISABLE_STD_ATOMIC)
@@ -299,11 +446,11 @@
 #   endif // (__cplusplus >= 201103)
 #  endif // defined(__clang__)
 #  if defined(__GNUC__)
-#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define ASIO_HAS_STD_ATOMIC 1
 #    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #  endif // defined(__GNUC__)
 #  if defined(ASIO_MSVC)
 #   if (_MSC_VER >= 1700)
@@ -354,6 +501,15 @@
 # endif // !defined(ASIO_DISABLE_BOOST_CHRONO)
 #endif // !defined(ASIO_HAS_BOOST_CHRONO)
 
+// Some form of chrono library is available.
+#if !defined(ASIO_HAS_CHRONO)
+# if defined(ASIO_HAS_STD_CHRONO) \
+    || defined(ASIO_HAS_BOOST_CHRONO)
+#  define ASIO_HAS_CHRONO 1
+# endif // defined(ASIO_HAS_STD_CHRONO)
+        // || defined(ASIO_HAS_BOOST_CHRONO)
+#endif // !defined(ASIO_HAS_CHRONO)
+
 // Boost support for the DateTime library.
 #if !defined(ASIO_HAS_BOOST_DATE_TIME)
 # if !defined(ASIO_DISABLE_BOOST_DATE_TIME)
@@ -438,6 +594,52 @@
 # endif // !defined(ASIO_DISABLE_STD_TYPE_TRAITS)
 #endif // !defined(ASIO_HAS_STD_TYPE_TRAITS)
 
+// Standard library support for the nullptr_t type.
+#if !defined(ASIO_HAS_NULLPTR)
+# if !defined(ASIO_DISABLE_NULLPTR)
+#  if defined(__clang__)
+#   if __has_feature(__cxx_nullptr__)
+#    define ASIO_HAS_NULLPTR 1
+#   endif // __has_feature(__cxx_rvalue_references__)
+#  elif defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define ASIO_HAS_NULLPTR 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define ASIO_HAS_NULLPTR 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_NULLPTR)
+#endif // !defined(ASIO_HAS_NULLPTR)
+
+// Standard library support for the C++11 allocator additions.
+#if !defined(ASIO_HAS_CXX11_ALLOCATORS)
+# if !defined(ASIO_DISABLE_CXX11_ALLOCATORS)
+#  if defined(__clang__)
+#   if defined(ASIO_HAS_CLANG_LIBCXX)
+#    define ASIO_HAS_CXX11_ALLOCATORS 1
+#   elif (__cplusplus >= 201103)
+#    define ASIO_HAS_CXX11_ALLOCATORS 1
+#   endif // (__cplusplus >= 201103)
+#  elif defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define ASIO_HAS_CXX11_ALLOCATORS 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1800)
+#    define ASIO_HAS_CXX11_ALLOCATORS 1
+#   endif // (_MSC_VER >= 1800)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_CXX11_ALLOCATORS)
+#endif // !defined(ASIO_HAS_CXX11_ALLOCATORS)
+
 // Standard library support for the cstdint header.
 #if !defined(ASIO_HAS_CSTDINT)
 # if !defined(ASIO_DISABLE_CSTDINT)
@@ -517,25 +719,182 @@
 # endif // !defined(ASIO_DISABLE_STD_MUTEX_AND_CONDVAR)
 #endif // !defined(ASIO_HAS_STD_MUTEX_AND_CONDVAR)
 
-// WinRT target.
-#if !defined(ASIO_WINDOWS_RUNTIME)
-# if defined(__cplusplus_winrt)
+// Standard library support for the call_once function.
+#if !defined(ASIO_HAS_STD_CALL_ONCE)
+# if !defined(ASIO_DISABLE_STD_CALL_ONCE)
+#  if defined(__clang__)
+#   if defined(ASIO_HAS_CLANG_LIBCXX)
+#    define ASIO_HAS_STD_CALL_ONCE 1
+#   elif (__cplusplus >= 201103)
+#    if __has_include(<mutex>)
+#     define ASIO_HAS_STD_CALL_ONCE 1
+#    endif // __has_include(<mutex>)
+#   endif // (__cplusplus >= 201103)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define ASIO_HAS_STD_CALL_ONCE 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define ASIO_HAS_STD_CALL_ONCE 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_STD_CALL_ONCE)
+#endif // !defined(ASIO_HAS_STD_CALL_ONCE)
+
+// Standard library support for futures.
+#if !defined(ASIO_HAS_STD_FUTURE)
+# if !defined(ASIO_DISABLE_STD_FUTURE)
+#  if defined(__clang__)
+#   if defined(ASIO_HAS_CLANG_LIBCXX)
+#    define ASIO_HAS_STD_FUTURE 1
+#   elif (__cplusplus >= 201103)
+#    if __has_include(<future>)
+#     define ASIO_HAS_STD_FUTURE 1
+#    endif // __has_include(<mutex>)
+#   endif // (__cplusplus >= 201103)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     if defined(_GLIBCXX_HAS_GTHREADS)
+#      define ASIO_HAS_STD_FUTURE 1
+#     endif // defined(_GLIBCXX_HAS_GTHREADS)
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define ASIO_HAS_STD_FUTURE 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_STD_FUTURE)
+#endif // !defined(ASIO_HAS_STD_FUTURE)
+
+// Standard library support for std::string_view.
+#if !defined(ASIO_HAS_STD_STRING_VIEW)
+# if !defined(ASIO_DISABLE_STD_STRING_VIEW)
+#  if defined(__clang__)
+#   if (__cplusplus >= 201703)
+#    if __has_include(<string_view>)
+#     define ASIO_HAS_STD_STRING_VIEW 1
+#    endif // __has_include(<string_view>)
+#   endif // (__cplusplus >= 201703)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if (__GNUC__ >= 7)
+#    if (__cplusplus >= 201703)
+#     define ASIO_HAS_STD_STRING_VIEW 1
+#    endif // (__cplusplus >= 201703)
+#   endif // (__GNUC__ >= 7)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1910 && _HAS_CXX17)
+#    define ASIO_HAS_STD_STRING_VIEW
+#   endif // (_MSC_VER >= 1910 && _HAS_CXX17)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_STD_STRING_VIEW)
+#endif // !defined(ASIO_HAS_STD_STRING_VIEW)
+
+// Standard library support for std::experimental::string_view.
+#if !defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+# if !defined(ASIO_DISABLE_STD_EXPERIMENTAL_STRING_VIEW)
+#  if defined(__clang__)
+#   if (__cplusplus >= 201402)
+#    if __has_include(<experimental/string_view>)
+#     define ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
+#    endif // __has_include(<experimental/string_view>)
+#   endif // (__cplusplus >= 201402)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
+#    if (__cplusplus >= 201402)
+#     define ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
+#    endif // (__cplusplus >= 201402)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+# endif // !defined(ASIO_DISABLE_STD_EXPERIMENTAL_STRING_VIEW)
+#endif // !defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+
+// Standard library has a string_view that we can use.
+#if !defined(ASIO_HAS_STRING_VIEW)
+# if !defined(ASIO_DISABLE_STRING_VIEW)
+#  if defined(ASIO_HAS_STD_STRING_VIEW)
+#   define ASIO_HAS_STRING_VIEW 1
+#  elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+#   define ASIO_HAS_STRING_VIEW 1
+#  endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+# endif // !defined(ASIO_DISABLE_STRING_VIEW)
+#endif // !defined(ASIO_HAS_STRING_VIEW)
+
+// Standard library support for iostream move construction and assignment.
+#if !defined(ASIO_HAS_STD_IOSTREAM_MOVE)
+# if !defined(ASIO_DISABLE_STD_IOSTREAM_MOVE)
+#  if defined(__GNUC__)
+#   if (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define ASIO_HAS_STD_IOSTREAM_MOVE 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define ASIO_HAS_STD_IOSTREAM_MOVE 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_STD_IOSTREAM_MOVE)
+#endif // !defined(ASIO_HAS_STD_IOSTREAM_MOVE)
+
+// Standard library has invoke_result (which supersedes result_of).
+#if !defined(ASIO_HAS_STD_INVOKE_RESULT)
+# if !defined(ASIO_DISABLE_STD_INVOKE_RESULT)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_VER >= 1910 && _HAS_CXX17)
+#    define ASIO_HAS_STD_INVOKE_RESULT 1
+#   endif // (_MSC_VER >= 1910 && _HAS_CXX17)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_STD_INVOKE_RESULT)
+#endif // !defined(ASIO_HAS_STD_INVOKE_RESULT)
+
+// Windows App target. Windows but with a limited API.
+#if !defined(ASIO_WINDOWS_APP)
+# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603)
 #  include <winapifamily.h>
 #  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \
    && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#   define ASIO_WINDOWS_RUNTIME 1
+#   define ASIO_WINDOWS_APP 1
 #  endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
          // && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-# endif // defined(__cplusplus_winrt)
+# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603)
+#endif // !defined(ASIO_WINDOWS_APP)
+
+// Legacy WinRT target. Windows App is preferred.
+#if !defined(ASIO_WINDOWS_RUNTIME)
+# if !defined(ASIO_WINDOWS_APP)
+#  if defined(__cplusplus_winrt)
+#   include <winapifamily.h>
+#   if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \
+    && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#    define ASIO_WINDOWS_RUNTIME 1
+#   endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+          // && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#  endif // defined(__cplusplus_winrt)
+# endif // !defined(ASIO_WINDOWS_APP)
 #endif // !defined(ASIO_WINDOWS_RUNTIME)
 
-// Windows target. Excludes WinRT.
+// Windows target. Excludes WinRT but includes Windows App targets.
 #if !defined(ASIO_WINDOWS)
 # if !defined(ASIO_WINDOWS_RUNTIME)
 #  if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
 #   define ASIO_WINDOWS 1
 #  elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
 #   define ASIO_WINDOWS 1
+#  elif defined(ASIO_WINDOWS_APP)
+#   define ASIO_WINDOWS 1
 #  endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
 # endif // !defined(ASIO_WINDOWS_RUNTIME)
 #endif // !defined(ASIO_WINDOWS)
@@ -603,11 +962,11 @@
 #if !defined(ASIO_HAS_IOCP)
 # if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 #  if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
-#   if !defined(UNDER_CE)
+#   if !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
 #    if !defined(ASIO_DISABLE_IOCP)
 #     define ASIO_HAS_IOCP 1
 #    endif // !defined(ASIO_DISABLE_IOCP)
-#   endif // !defined(UNDER_CE)
+#   endif // !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
 #  endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
 # endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 #endif // !defined(ASIO_HAS_IOCP)
@@ -723,9 +1082,9 @@
 #if !defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
 # if !defined(ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
 #  if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#   if !defined(UNDER_CE)
+#   if !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
 #    define ASIO_HAS_WINDOWS_OBJECT_HANDLE 1
-#   endif // !defined(UNDER_CE)
+#   endif // !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
 #  endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 # endif // !defined(ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
 #endif // !defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
@@ -789,15 +1148,25 @@
 
 // Can use getaddrinfo() and getnameinfo().
 #if !defined(ASIO_HAS_GETADDRINFO)
-# if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#  if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
-#   define ASIO_HAS_GETADDRINFO 1
-#  elif defined(UNDER_CE)
+# if !defined(ASIO_DISABLE_GETADDRINFO)
+#  if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+#   if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
+#    define ASIO_HAS_GETADDRINFO 1
+#   elif defined(UNDER_CE)
+#    define ASIO_HAS_GETADDRINFO 1
+#   endif // defined(UNDER_CE)
+#  elif defined(__MACH__) && defined(__APPLE__)
+#   if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#    if (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+#     define ASIO_HAS_GETADDRINFO 1
+#    endif // (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+#   else // defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#    define ASIO_HAS_GETADDRINFO 1
+#   endif // defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#  else // defined(__MACH__) && defined(__APPLE__)
 #   define ASIO_HAS_GETADDRINFO 1
-#  endif // defined(UNDER_CE)
-# elif !(defined(__MACH__) && defined(__APPLE__))
-#  define ASIO_HAS_GETADDRINFO 1
-# endif // !(defined(__MACH__) && defined(__APPLE__))
+#  endif // defined(__MACH__) && defined(__APPLE__)
+# endif // !defined(ASIO_DISABLE_GETADDRINFO)
 #endif // !defined(ASIO_HAS_GETADDRINFO)
 
 // Whether standard iostreams are disabled.
@@ -826,11 +1195,18 @@
 # if !defined(ASIO_DISABLE_THREADS)
 #  if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
 #   define ASIO_HAS_THREADS 1
-#  elif defined(_MSC_VER) && defined(_MT)
+#  elif defined(__GNUC__) && !defined(__MINGW32__) \
+     && !defined(linux) && !defined(__linux) && !defined(__linux__)
+#   define ASIO_HAS_THREADS 1
+#  elif defined(_MT) || defined(__MT__)
+#   define ASIO_HAS_THREADS 1
+#  elif defined(_REENTRANT)
 #   define ASIO_HAS_THREADS 1
-#  elif defined(__BORLANDC__) && defined(__MT__)
+#  elif defined(__APPLE__)
 #   define ASIO_HAS_THREADS 1
-#  elif defined(_POSIX_THREADS)
+#  elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0)
+#   define ASIO_HAS_THREADS 1
+#  elif defined(_PTHREADS)
 #   define ASIO_HAS_THREADS 1
 #  endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
 # endif // !defined(ASIO_DISABLE_THREADS)
@@ -841,7 +1217,7 @@
 # if defined(ASIO_HAS_THREADS)
 #  if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
 #   define ASIO_HAS_PTHREADS 1
-#  elif defined(_POSIX_THREADS)
+#  elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0)
 #   define ASIO_HAS_PTHREADS 1
 #  endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
 # endif // defined(ASIO_HAS_THREADS)
@@ -941,12 +1317,14 @@
 # if defined(__linux__)
 #  if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 #   if ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
-#    if !defined(__INTEL_COMPILER) && !defined(__ICL)
+#    if !defined(__INTEL_COMPILER) && !defined(__ICL) \
+       && !(defined(__clang__) && defined(__ANDROID__))
 #     define ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
 #     define ASIO_THREAD_KEYWORD __thread
 #    elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
 #     define ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
 #    endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
+           // && !(defined(__clang__) && defined(__ANDROID__))
 #   endif // ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
 #  endif // defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 # endif // defined(__linux__)
@@ -970,4 +1348,90 @@
         //   || (defined(__MACH__) && defined(__APPLE__))
 #endif // !defined(ASIO_DISABLE_SSIZE_T)
 
+// Helper macros to manage the transition away from the old services-based API.
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# define ASIO_SVC_TPARAM , typename Service
+# define ASIO_SVC_TPARAM_DEF1(d1) , typename Service d1
+# define ASIO_SVC_TPARAM_DEF2(d1, d2) , typename Service d1, d2
+# define ASIO_SVC_TARG , Service
+# define ASIO_SVC_T Service
+# define ASIO_SVC_TPARAM1 , typename Service1
+# define ASIO_SVC_TPARAM1_DEF1(d1) , typename Service1 d1
+# define ASIO_SVC_TPARAM1_DEF2(d1, d2) , typename Service1 d1, d2
+# define ASIO_SVC_TARG1 , Service1
+# define ASIO_SVC_T1 Service1
+# define ASIO_SVC_ACCESS public
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+# define ASIO_SVC_TPARAM
+# define ASIO_SVC_TPARAM_DEF1(d1)
+# define ASIO_SVC_TPARAM_DEF2(d1, d2)
+# define ASIO_SVC_TARG
+// ASIO_SVC_T is defined at each point of use.
+# define ASIO_SVC_TPARAM1
+# define ASIO_SVC_TPARAM1_DEF1(d1)
+# define ASIO_SVC_TPARAM1_DEF2(d1, d2)
+# define ASIO_SVC_TARG1
+// ASIO_SVC_T1 is defined at each point of use.
+# define ASIO_SVC_ACCESS protected
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+// Helper macros to manage transition away from error_code return values.
+#if defined(ASIO_NO_DEPRECATED)
+# define ASIO_SYNC_OP_VOID void
+# define ASIO_SYNC_OP_VOID_RETURN(e) return
+#else // defined(ASIO_NO_DEPRECATED)
+# define ASIO_SYNC_OP_VOID asio::error_code
+# define ASIO_SYNC_OP_VOID_RETURN(e) return e
+#endif // defined(ASIO_NO_DEPRECATED)
+
+// Newer gcc, clang need special treatment to suppress unused typedef warnings.
+#if defined(__clang__)
+# if defined(__apple_build_version__)
+#  if (__clang_major__ >= 7)
+#   define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
+#  endif // (__clang_major__ >= 7)
+# elif ((__clang_major__ == 3) && (__clang_minor__ >= 6)) \
+    || (__clang_major__ > 3)
+#  define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
+# endif // ((__clang_major__ == 3) && (__clang_minor__ >= 6))
+        //   || (__clang_major__ > 3)
+#elif defined(__GNUC__)
+# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
+#  define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
+# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
+#endif // defined(__GNUC__)
+#if !defined(ASIO_UNUSED_TYPEDEF)
+# define ASIO_UNUSED_TYPEDEF
+#endif // !defined(ASIO_UNUSED_TYPEDEF)
+
+// Some versions of gcc generate spurious warnings about unused variables.
+#if defined(__GNUC__)
+# if (__GNUC__ >= 4)
+#  define ASIO_UNUSED_VARIABLE __attribute__((__unused__))
+# endif // (__GNUC__ >= 4)
+#endif // defined(__GNUC__)
+#if !defined(ASIO_UNUSED_VARIABLE)
+# define ASIO_UNUSED_VARIABLE
+#endif // !defined(ASIO_UNUSED_VARIABLE)
+
+// Support co_await on compilers known to allow it.
+#if !defined(ASIO_HAS_CO_AWAIT)
+# if !defined(ASIO_DISABLE_CO_AWAIT)
+#  if defined(ASIO_MSVC)
+#   if (_MSC_FULL_VER >= 190023506)
+#    if defined(_RESUMABLE_FUNCTIONS_SUPPORTED)
+#     define ASIO_HAS_CO_AWAIT 1
+#    endif // defined(_RESUMABLE_FUNCTIONS_SUPPORTED)
+#   endif // (_MSC_FULL_VER >= 190023506)
+#  endif // defined(ASIO_MSVC)
+# endif // !defined(ASIO_DISABLE_CO_AWAIT)
+# if defined(__clang__)
+#  if (__cpp_coroutines >= 201703)
+#   if __has_include(<experimental/coroutine>)
+#    define ASIO_HAS_CO_AWAIT 1
+#   endif // __has_include(<experimental/coroutine>)
+#  endif // (__cpp_coroutines >= 201703)
+# endif // defined(__clang__)
+#endif // !defined(ASIO_HAS_CO_AWAIT)
+
 #endif // ASIO_DETAIL_CONFIG_HPP
diff --git a/extern/include/asio/detail/consuming_buffers.hpp b/extern/include/asio/detail/consuming_buffers.hpp
index 37c9ffa3..8127ae75 100644
--- a/extern/include/asio/detail/consuming_buffers.hpp
+++ b/extern/include/asio/detail/consuming_buffers.hpp
@@ -2,7 +2,7 @@
 // detail/consuming_buffers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,8 +17,8 @@
 
 #include "asio/detail/config.hpp"
 #include <cstddef>
-#include <iterator>
 #include "asio/buffer.hpp"
+#include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/limits.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -26,262 +26,384 @@
 namespace asio {
 namespace detail {
 
-// A proxy iterator for a sub-range in a list of buffers.
-template <typename Buffer, typename Buffer_Iterator>
-class consuming_buffers_iterator
+// Helper template to determine the maximum number of prepared buffers.
+template <typename Buffers>
+struct prepared_buffers_max
 {
-public:
-  /// The type used for the distance between two iterators.
-  typedef std::ptrdiff_t difference_type;
+  enum { value = buffer_sequence_adapter_base::max_buffers };
+};
+
+template <typename Elem, std::size_t N>
+struct prepared_buffers_max<boost::array<Elem, N> >
+{
+  enum { value = N };
+};
+
+#if defined(ASIO_HAS_STD_ARRAY)
+
+template <typename Elem, std::size_t N>
+struct prepared_buffers_max<std::array<Elem, N> >
+{
+  enum { value = N };
+};
 
-  /// The type of the value pointed to by the iterator.
+#endif // defined(ASIO_HAS_STD_ARRAY)
+
+// A buffer sequence used to represent a subsequence of the buffers.
+template <typename Buffer, std::size_t MaxBuffers>
+struct prepared_buffers
+{
   typedef Buffer value_type;
+  typedef const Buffer* const_iterator;
 
-  /// The type of the result of applying operator->() to the iterator.
-  typedef const Buffer* pointer;
+  enum { max_buffers = MaxBuffers < 16 ? MaxBuffers : 16 };
 
-  /// The type of the result of applying operator*() to the iterator.
-  typedef const Buffer& reference;
+  prepared_buffers() : count(0) {}
+  const_iterator begin() const { return elems; }
+  const_iterator end() const { return elems + count; }
+
+  Buffer elems[max_buffers];
+  std::size_t count;
+};
 
-  /// The iterator category.
-  typedef std::forward_iterator_tag iterator_category;
+// A proxy for a sub-range in a list of buffers.
+template <typename Buffer, typename Buffers, typename Buffer_Iterator>
+class consuming_buffers
+{
+public:
+  typedef prepared_buffers<Buffer, prepared_buffers_max<Buffers>::value>
+    prepared_buffers_type;
 
-  // Default constructor creates an end iterator.
-  consuming_buffers_iterator()
-    : at_end_(true)
+  // Construct to represent the entire list of buffers.
+  explicit consuming_buffers(const Buffers& buffers)
+    : buffers_(buffers),
+      total_consumed_(0),
+      next_elem_(0),
+      next_elem_offset_(0)
   {
+    using asio::buffer_size;
+    total_size_ = buffer_size(buffers);
   }
 
-  // Construct with a buffer for the first entry and an iterator
-  // range for the remaining entries.
-  consuming_buffers_iterator(bool at_end, const Buffer& first,
-      Buffer_Iterator begin_remainder, Buffer_Iterator end_remainder,
-      std::size_t max_size)
-    : at_end_(max_size > 0 ? at_end : true),
-      first_(buffer(first, max_size)),
-      begin_remainder_(begin_remainder),
-      end_remainder_(end_remainder),
-      offset_(0),
-      max_size_(max_size)
+  // Determine if we are at the end of the buffers.
+  bool empty() const
   {
+    return total_consumed_ >= total_size_;
   }
 
-  // Dereference an iterator.
-  const Buffer& operator*() const
+  // Get the buffer for a single transfer, with a size.
+  prepared_buffers_type prepare(std::size_t max_size)
   {
-    return dereference();
+    prepared_buffers_type result;
+
+    Buffer_Iterator next = asio::buffer_sequence_begin(buffers_);
+    Buffer_Iterator end = asio::buffer_sequence_end(buffers_);
+
+    std::advance(next, next_elem_);
+    std::size_t elem_offset = next_elem_offset_;
+    while (next != end && max_size > 0 && (result.count) < result.max_buffers)
+    {
+      Buffer next_buf = Buffer(*next) + elem_offset;
+      result.elems[result.count] = asio::buffer(next_buf, max_size);
+      max_size -= result.elems[result.count].size();
+      elem_offset = 0;
+      if (result.elems[result.count].size() > 0)
+        ++result.count;
+      ++next;
+    }
+
+    return result;
   }
 
-  // Dereference an iterator.
-  const Buffer* operator->() const
+  // Consume the specified number of bytes from the buffers.
+  void consume(std::size_t size)
+  {
+    total_consumed_ += size;
+
+    Buffer_Iterator next = asio::buffer_sequence_begin(buffers_);
+    Buffer_Iterator end = asio::buffer_sequence_end(buffers_);
+
+    std::advance(next, next_elem_);
+    while (next != end && size > 0)
+    {
+      Buffer next_buf = Buffer(*next) + next_elem_offset_;
+      if (size < next_buf.size())
+      {
+        next_elem_offset_ += size;
+        size = 0;
+      }
+      else
+      {
+        size -= next_buf.size();
+        next_elem_offset_ = 0;
+        ++next_elem_;
+        ++next;
+      }
+    }
+  }
+
+  // Get the total number of bytes consumed from the buffers.
+  std::size_t total_consumed() const
+  {
+    return total_consumed_;
+  }
+
+private:
+  Buffers buffers_;
+  std::size_t total_size_;
+  std::size_t total_consumed_;
+  std::size_t next_elem_;
+  std::size_t next_elem_offset_;
+};
+
+// Base class of all consuming_buffers specialisations for single buffers.
+template <typename Buffer>
+class consuming_single_buffer
+{
+public:
+  // Construct to represent the entire list of buffers.
+  template <typename Buffer1>
+  explicit consuming_single_buffer(const Buffer1& buffer)
+    : buffer_(buffer),
+      total_consumed_(0)
   {
-    return &dereference();
   }
 
-  // Increment operator (prefix).
-  consuming_buffers_iterator& operator++()
+  // Determine if we are at the end of the buffers.
+  bool empty() const
   {
-    increment();
-    return *this;
+    return total_consumed_ >= buffer_.size();
   }
 
-  // Increment operator (postfix).
-  consuming_buffers_iterator operator++(int)
+  // Get the buffer for a single transfer, with a size.
+  Buffer prepare(std::size_t max_size)
   {
-    consuming_buffers_iterator tmp(*this);
-    ++*this;
-    return tmp;
+    return asio::buffer(buffer_ + total_consumed_, max_size);
   }
 
-  // Test two iterators for equality.
-  friend bool operator==(const consuming_buffers_iterator& a,
-      const consuming_buffers_iterator& b)
+  // Consume the specified number of bytes from the buffers.
+  void consume(std::size_t size)
   {
-    return a.equal(b);
+    total_consumed_ += size;
   }
 
-  // Test two iterators for inequality.
-  friend bool operator!=(const consuming_buffers_iterator& a,
-      const consuming_buffers_iterator& b)
+  // Get the total number of bytes consumed from the buffers.
+  std::size_t total_consumed() const
   {
-    return !a.equal(b);
+    return total_consumed_;
   }
 
 private:
-  void increment()
+  Buffer buffer_;
+  std::size_t total_consumed_;
+};
+
+template <>
+class consuming_buffers<mutable_buffer, mutable_buffer, const mutable_buffer*>
+  : public consuming_single_buffer<ASIO_MUTABLE_BUFFER>
+{
+public:
+  explicit consuming_buffers(const mutable_buffer& buffer)
+    : consuming_single_buffer<ASIO_MUTABLE_BUFFER>(buffer)
   {
-    if (!at_end_)
-    {
-      if (begin_remainder_ == end_remainder_
-          || offset_ + buffer_size(first_) >= max_size_)
-      {
-        at_end_ = true;
-      }
-      else
-      {
-        offset_ += buffer_size(first_);
-        first_ = buffer(*begin_remainder_++, max_size_ - offset_);
-      }
-    }
   }
+};
 
-  bool equal(const consuming_buffers_iterator& other) const
+template <>
+class consuming_buffers<const_buffer, mutable_buffer, const mutable_buffer*>
+  : public consuming_single_buffer<ASIO_CONST_BUFFER>
+{
+public:
+  explicit consuming_buffers(const mutable_buffer& buffer)
+    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
   {
-    if (at_end_ && other.at_end_)
-      return true;
-    return !at_end_ && !other.at_end_
-      && buffer_cast<const void*>(first_)
-        == buffer_cast<const void*>(other.first_)
-      && buffer_size(first_) == buffer_size(other.first_)
-      && begin_remainder_ == other.begin_remainder_
-      && end_remainder_ == other.end_remainder_;
   }
+};
 
-  const Buffer& dereference() const
+template <>
+class consuming_buffers<const_buffer, const_buffer, const const_buffer*>
+  : public consuming_single_buffer<ASIO_CONST_BUFFER>
+{
+public:
+  explicit consuming_buffers(const const_buffer& buffer)
+    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
   {
-    return first_;
   }
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
 
-  bool at_end_;
-  Buffer first_;
-  Buffer_Iterator begin_remainder_;
-  Buffer_Iterator end_remainder_;
-  std::size_t offset_;
-  std::size_t max_size_;
+template <>
+class consuming_buffers<mutable_buffer,
+    mutable_buffers_1, const mutable_buffer*>
+  : public consuming_single_buffer<ASIO_MUTABLE_BUFFER>
+{
+public:
+  explicit consuming_buffers(const mutable_buffers_1& buffer)
+    : consuming_single_buffer<ASIO_MUTABLE_BUFFER>(buffer)
+  {
+  }
 };
 
-// A proxy for a sub-range in a list of buffers.
-template <typename Buffer, typename Buffers>
-class consuming_buffers
+template <>
+class consuming_buffers<const_buffer, mutable_buffers_1, const mutable_buffer*>
+  : public consuming_single_buffer<ASIO_CONST_BUFFER>
 {
 public:
-  // The type for each element in the list of buffers.
-  typedef Buffer value_type;
+  explicit consuming_buffers(const mutable_buffers_1& buffer)
+    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
+  {
+  }
+};
 
-  // A forward-only iterator type that may be used to read elements.
-  typedef consuming_buffers_iterator<Buffer, typename Buffers::const_iterator>
-    const_iterator;
+template <>
+class consuming_buffers<const_buffer, const_buffers_1, const const_buffer*>
+  : public consuming_single_buffer<ASIO_CONST_BUFFER>
+{
+public:
+  explicit consuming_buffers(const const_buffers_1& buffer)
+    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
+  {
+  }
+};
+
+#endif // !defined(ASIO_NO_DEPRECATED)
 
+template <typename Buffer, typename Elem>
+class consuming_buffers<Buffer, boost::array<Elem, 2>,
+    typename boost::array<Elem, 2>::const_iterator>
+{
+public:
   // Construct to represent the entire list of buffers.
-  consuming_buffers(const Buffers& buffers)
+  explicit consuming_buffers(const boost::array<Elem, 2>& buffers)
     : buffers_(buffers),
-      at_end_(buffers_.begin() == buffers_.end()),
-      begin_remainder_(buffers_.begin()),
-      max_size_((std::numeric_limits<std::size_t>::max)())
+      total_consumed_(0)
   {
-    if (!at_end_)
-    {
-      first_ = *buffers_.begin();
-      ++begin_remainder_;
-    }
   }
 
-  // Copy constructor.
-  consuming_buffers(const consuming_buffers& other)
-    : buffers_(other.buffers_),
-      at_end_(other.at_end_),
-      first_(other.first_),
-      begin_remainder_(buffers_.begin()),
-      max_size_(other.max_size_)
+  // Determine if we are at the end of the buffers.
+  bool empty() const
+  {
+    return total_consumed_ >=
+      Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
+  }
+
+  // Get the buffer for a single transfer, with a size.
+  boost::array<Buffer, 2> prepare(std::size_t max_size)
+  {
+    boost::array<Buffer, 2> result = {{
+      Buffer(buffers_[0]), Buffer(buffers_[1]) }};
+    std::size_t buffer0_size = result[0].size();
+    result[0] = asio::buffer(result[0] + total_consumed_, max_size);
+    result[1] = asio::buffer(
+        result[1] + (total_consumed_ < buffer0_size
+          ? 0 : total_consumed_ - buffer0_size),
+        max_size - result[0].size());
+    return result;
+  }
+
+  // Consume the specified number of bytes from the buffers.
+  void consume(std::size_t size)
   {
-    typename Buffers::const_iterator first = other.buffers_.begin();
-    typename Buffers::const_iterator second = other.begin_remainder_;
-    std::advance(begin_remainder_, std::distance(first, second));
+    total_consumed_ += size;
   }
 
-  // Assignment operator.
-  consuming_buffers& operator=(const consuming_buffers& other)
+  // Get the total number of bytes consumed from the buffers.
+  std::size_t total_consumed() const
   {
-    buffers_ = other.buffers_;
-    at_end_ = other.at_end_;
-    first_ = other.first_;
-    begin_remainder_ = buffers_.begin();
-    typename Buffers::const_iterator first = other.buffers_.begin();
-    typename Buffers::const_iterator second = other.begin_remainder_;
-    std::advance(begin_remainder_, std::distance(first, second));
-    max_size_ = other.max_size_;
-    return *this;
+    return total_consumed_;
   }
 
-  // Get a forward-only iterator to the first element.
-  const_iterator begin() const
+private:
+  boost::array<Elem, 2> buffers_;
+  std::size_t total_consumed_;
+};
+
+#if defined(ASIO_HAS_STD_ARRAY)
+
+template <typename Buffer, typename Elem>
+class consuming_buffers<Buffer, std::array<Elem, 2>,
+    typename std::array<Elem, 2>::const_iterator>
+{
+public:
+  // Construct to represent the entire list of buffers.
+  explicit consuming_buffers(const std::array<Elem, 2>& buffers)
+    : buffers_(buffers),
+      total_consumed_(0)
   {
-    return const_iterator(at_end_, first_,
-        begin_remainder_, buffers_.end(), max_size_);
   }
 
-  // Get a forward-only iterator for one past the last element.
-  const_iterator end() const
+  // Determine if we are at the end of the buffers.
+  bool empty() const
   {
-    return const_iterator();
+    return total_consumed_ >=
+      Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
   }
 
-  // Set the maximum size for a single transfer.
-  void prepare(std::size_t max_size)
+  // Get the buffer for a single transfer, with a size.
+  std::array<Buffer, 2> prepare(std::size_t max_size)
   {
-    max_size_ = max_size;
+    std::array<Buffer, 2> result = {{
+      Buffer(buffers_[0]), Buffer(buffers_[1]) }};
+    std::size_t buffer0_size = result[0].size();
+    result[0] = asio::buffer(result[0] + total_consumed_, max_size);
+    result[1] = asio::buffer(
+        result[1] + (total_consumed_ < buffer0_size
+          ? 0 : total_consumed_ - buffer0_size),
+        max_size - result[0].size());
+    return result;
   }
 
   // Consume the specified number of bytes from the buffers.
   void consume(std::size_t size)
   {
-    // Remove buffers from the start until the specified size is reached.
-    while (size > 0 && !at_end_)
-    {
-      if (buffer_size(first_) <= size)
-      {
-        size -= buffer_size(first_);
-        if (begin_remainder_ == buffers_.end())
-          at_end_ = true;
-        else
-          first_ = *begin_remainder_++;
-      }
-      else
-      {
-        first_ = first_ + size;
-        size = 0;
-      }
-    }
+    total_consumed_ += size;
+  }
 
-    // Remove any more empty buffers at the start.
-    while (!at_end_ && buffer_size(first_) == 0)
-    {
-      if (begin_remainder_ == buffers_.end())
-        at_end_ = true;
-      else
-        first_ = *begin_remainder_++;
-    }
+  // Get the total number of bytes consumed from the buffers.
+  std::size_t total_consumed() const
+  {
+    return total_consumed_;
   }
 
 private:
-  Buffers buffers_;
-  bool at_end_;
-  Buffer first_;
-  typename Buffers::const_iterator begin_remainder_;
-  std::size_t max_size_;
+  std::array<Elem, 2> buffers_;
+  std::size_t total_consumed_;
 };
 
+#endif // defined(ASIO_HAS_STD_ARRAY)
+
 // Specialisation for null_buffers to ensure that the null_buffers type is
 // always passed through to the underlying read or write operation.
 template <typename Buffer>
-class consuming_buffers<Buffer, asio::null_buffers>
+class consuming_buffers<Buffer, null_buffers, const mutable_buffer*>
   : public asio::null_buffers
 {
 public:
-  consuming_buffers(const asio::null_buffers&)
+  consuming_buffers(const null_buffers&)
   {
     // No-op.
   }
 
-  void prepare(std::size_t)
+  bool empty()
   {
-    // No-op.
+    return false;
+  }
+
+  null_buffers prepare(std::size_t)
+  {
+    return null_buffers();
   }
 
   void consume(std::size_t)
   {
     // No-op.
   }
+
+  std::size_t total_consumed() const
+  {
+    return 0;
+  }
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/cstddef.hpp b/extern/include/asio/detail/cstddef.hpp
new file mode 100644
index 00000000..3912da40
--- /dev/null
+++ b/extern/include/asio/detail/cstddef.hpp
@@ -0,0 +1,31 @@
+//
+// detail/cstddef.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_CSTDDEF_HPP
+#define ASIO_DETAIL_CSTDDEF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <cstddef>
+
+namespace asio {
+
+#if defined(ASIO_HAS_NULLPTR)
+using std::nullptr_t;
+#else // defined(ASIO_HAS_NULLPTR)
+struct nullptr_t {};
+#endif // defined(ASIO_HAS_NULLPTR)
+
+} // namespace asio
+
+#endif // ASIO_DETAIL_CSTDDEF_HPP
diff --git a/extern/include/asio/detail/cstdint.hpp b/extern/include/asio/detail/cstdint.hpp
index e3ee84ce..62342b2d 100644
--- a/extern/include/asio/detail/cstdint.hpp
+++ b/extern/include/asio/detail/cstdint.hpp
@@ -2,7 +2,7 @@
 // detail/cstdint.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -27,18 +27,32 @@ namespace asio {
 
 #if defined(ASIO_HAS_CSTDINT)
 using std::int16_t;
+using std::int_least16_t;
 using std::uint16_t;
+using std::uint_least16_t;
 using std::int32_t;
+using std::int_least32_t;
 using std::uint32_t;
+using std::uint_least32_t;
 using std::int64_t;
+using std::int_least64_t;
 using std::uint64_t;
+using std::uint_least64_t;
+using std::uintmax_t;
 #else // defined(ASIO_HAS_CSTDINT)
 using boost::int16_t;
+using boost::int_least16_t;
 using boost::uint16_t;
+using boost::uint_least16_t;
 using boost::int32_t;
+using boost::int_least32_t;
 using boost::uint32_t;
+using boost::uint_least32_t;
 using boost::int64_t;
+using boost::int_least64_t;
 using boost::uint64_t;
+using boost::uint_least64_t;
+using boost::uintmax_t;
 #endif // defined(ASIO_HAS_CSTDINT)
 
 } // namespace asio
diff --git a/extern/include/asio/detail/date_time_fwd.hpp b/extern/include/asio/detail/date_time_fwd.hpp
index 74e33a9a..a159562e 100644
--- a/extern/include/asio/detail/date_time_fwd.hpp
+++ b/extern/include/asio/detail/date_time_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/date_time_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/deadline_timer_service.hpp b/extern/include/asio/detail/deadline_timer_service.hpp
index ef1c9a92..f58a6e0e 100644
--- a/extern/include/asio/detail/deadline_timer_service.hpp
+++ b/extern/include/asio/detail/deadline_timer_service.hpp
@@ -2,7 +2,7 @@
 // detail/deadline_timer_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,14 +18,15 @@
 #include "asio/detail/config.hpp"
 #include <cstddef>
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/detail/socket_types.hpp"
 #include "asio/detail/timer_queue.hpp"
+#include "asio/detail/timer_queue_ptime.hpp"
 #include "asio/detail/timer_scheduler.hpp"
 #include "asio/detail/wait_handler.hpp"
 #include "asio/detail/wait_op.hpp"
@@ -42,6 +43,7 @@ namespace detail {
 
 template <typename Time_Traits>
 class deadline_timer_service
+  : public service_base<deadline_timer_service<Time_Traits> >
 {
 public:
   // The time type.
@@ -61,8 +63,9 @@ class deadline_timer_service
   };
 
   // Constructor.
-  deadline_timer_service(asio::io_service& io_service)
-    : scheduler_(asio::use_service<timer_scheduler>(io_service))
+  deadline_timer_service(asio::io_context& io_context)
+    : service_base<deadline_timer_service<Time_Traits> >(io_context),
+      scheduler_(asio::use_service<timer_scheduler>(io_context))
   {
     scheduler_.init_task();
     scheduler_.add_timer_queue(timer_queue_);
@@ -75,7 +78,7 @@ class deadline_timer_service
   }
 
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
   }
 
@@ -93,6 +96,38 @@ class deadline_timer_service
     cancel(impl, ec);
   }
 
+  // Move-construct a new serial port implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    scheduler_.move_timer(timer_queue_, impl.timer_data, other_impl.timer_data);
+
+    impl.expiry = other_impl.expiry;
+    other_impl.expiry = time_type();
+
+    impl.might_have_pending_waits = other_impl.might_have_pending_waits;
+    other_impl.might_have_pending_waits = false;
+  }
+
+  // Move-assign from another serial port implementation.
+  void move_assign(implementation_type& impl,
+      deadline_timer_service& other_service,
+      implementation_type& other_impl)
+  {
+    if (this != &other_service)
+      if (impl.might_have_pending_waits)
+        scheduler_.cancel_timer(timer_queue_, impl.timer_data);
+
+    other_service.scheduler_.move_timer(other_service.timer_queue_,
+        impl.timer_data, other_impl.timer_data);
+
+    impl.expiry = other_impl.expiry;
+    other_impl.expiry = time_type();
+
+    impl.might_have_pending_waits = other_impl.might_have_pending_waits;
+    other_impl.might_have_pending_waits = false;
+  }
+
   // Cancel any asynchronous wait operations associated with the timer.
   std::size_t cancel(implementation_type& impl, asio::error_code& ec)
   {
@@ -102,7 +137,8 @@ class deadline_timer_service
       return 0;
     }
 
-    ASIO_HANDLER_OPERATION(("deadline_timer", &impl, "cancel"));
+    ASIO_HANDLER_OPERATION((scheduler_.context(),
+          "deadline_timer", &impl, 0, "cancel"));
 
     std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
     impl.might_have_pending_waits = false;
@@ -120,7 +156,8 @@ class deadline_timer_service
       return 0;
     }
 
-    ASIO_HANDLER_OPERATION(("deadline_timer", &impl, "cancel_one"));
+    ASIO_HANDLER_OPERATION((scheduler_.context(),
+          "deadline_timer", &impl, 0, "cancel_one"));
 
     std::size_t count = scheduler_.cancel_timer(
         timer_queue_, impl.timer_data, 1);
@@ -130,12 +167,24 @@ class deadline_timer_service
     return count;
   }
 
+  // Get the expiry time for the timer as an absolute time.
+  time_type expiry(const implementation_type& impl) const
+  {
+    return impl.expiry;
+  }
+
   // Get the expiry time for the timer as an absolute time.
   time_type expires_at(const implementation_type& impl) const
   {
     return impl.expiry;
   }
 
+  // Get the expiry time for the timer relative to now.
+  duration_type expires_from_now(const implementation_type& impl) const
+  {
+    return Time_Traits::subtract(this->expiry(impl), Time_Traits::now());
+  }
+
   // Set the expiry time for the timer as an absolute time.
   std::size_t expires_at(implementation_type& impl,
       const time_type& expiry_time, asio::error_code& ec)
@@ -146,10 +195,12 @@ class deadline_timer_service
     return count;
   }
 
-  // Get the expiry time for the timer relative to now.
-  duration_type expires_from_now(const implementation_type& impl) const
+  // Set the expiry time for the timer relative to now.
+  std::size_t expires_after(implementation_type& impl,
+      const duration_type& expiry_time, asio::error_code& ec)
   {
-    return Time_Traits::subtract(expires_at(impl), Time_Traits::now());
+    return expires_at(impl,
+        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
   }
 
   // Set the expiry time for the timer relative to now.
@@ -180,13 +231,13 @@ class deadline_timer_service
     // Allocate and construct an operation to wrap the handler.
     typedef wait_handler<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
     impl.might_have_pending_waits = true;
 
-    ASIO_HANDLER_CREATION((p.p, "deadline_timer", &impl, "async_wait"));
+    ASIO_HANDLER_CREATION((scheduler_.context(),
+          *p.p, "deadline_timer", &impl, 0, "async_wait"));
 
     scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
     p.v = p.p = 0;
diff --git a/extern/include/asio/detail/dependent_type.hpp b/extern/include/asio/detail/dependent_type.hpp
index abb48179..85b41c89 100644
--- a/extern/include/asio/detail/dependent_type.hpp
+++ b/extern/include/asio/detail/dependent_type.hpp
@@ -2,7 +2,7 @@
 // detail/dependent_type.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/descriptor_ops.hpp b/extern/include/asio/detail/descriptor_ops.hpp
index 5d261252..9c0560aa 100644
--- a/extern/include/asio/detail/descriptor_ops.hpp
+++ b/extern/include/asio/detail/descriptor_ops.hpp
@@ -2,7 +2,7 @@
 // detail/descriptor_ops.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,6 +22,7 @@
   && !defined(__CYGWIN__)
 
 #include <cstddef>
+#include "asio/error.hpp"
 #include "asio/error_code.hpp"
 #include "asio/detail/socket_types.hpp"
 
@@ -100,6 +101,9 @@ ASIO_DECL int poll_read(int d,
 ASIO_DECL int poll_write(int d,
     state_type state, asio::error_code& ec);
 
+ASIO_DECL int poll_error(int d,
+    state_type state, asio::error_code& ec);
+
 } // namespace descriptor_ops
 } // namespace detail
 } // namespace asio
diff --git a/extern/include/asio/detail/descriptor_read_op.hpp b/extern/include/asio/detail/descriptor_read_op.hpp
index 2cfdf577..6db4bfb9 100644
--- a/extern/include/asio/detail/descriptor_read_op.hpp
+++ b/extern/include/asio/detail/descriptor_read_op.hpp
@@ -2,7 +2,7 @@
 // detail/descriptor_read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,11 +19,12 @@
 
 #if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/descriptor_ops.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_work.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -43,15 +44,21 @@ class descriptor_read_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
 
     buffer_sequence_adapter<asio::mutable_buffer,
         MutableBufferSequence> bufs(o->buffers_);
 
-    return descriptor_ops::non_blocking_read(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
+    status result = descriptor_ops::non_blocking_read(o->descriptor_,
+        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
+      ? done : not_done;
+
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_read",
+          o->ec_, o->bytes_transferred_));
+
+    return result;
   }
 
 private:
@@ -72,17 +79,19 @@ class descriptor_read_op
         descriptor, buffers, &descriptor_read_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -100,7 +109,7 @@ class descriptor_read_op
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/descriptor_write_op.hpp b/extern/include/asio/detail/descriptor_write_op.hpp
index 9f53e584..a9ec2a97 100644
--- a/extern/include/asio/detail/descriptor_write_op.hpp
+++ b/extern/include/asio/detail/descriptor_write_op.hpp
@@ -2,7 +2,7 @@
 // detail/descriptor_write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,11 +19,12 @@
 
 #if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/descriptor_ops.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_work.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -43,15 +44,21 @@ class descriptor_write_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
 
     buffer_sequence_adapter<asio::const_buffer,
         ConstBufferSequence> bufs(o->buffers_);
 
-    return descriptor_ops::non_blocking_write(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
+    status result = descriptor_ops::non_blocking_write(o->descriptor_,
+        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
+      ? done : not_done;
+
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_write",
+          o->ec_, o->bytes_transferred_));
+
+    return result;
   }
 
 private:
@@ -72,17 +79,19 @@ class descriptor_write_op
         descriptor, buffers, &descriptor_write_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -100,7 +109,7 @@ class descriptor_write_op
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/dev_poll_reactor.hpp b/extern/include/asio/detail/dev_poll_reactor.hpp
index a91a6155..e9e4e29e 100644
--- a/extern/include/asio/detail/dev_poll_reactor.hpp
+++ b/extern/include/asio/detail/dev_poll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/dev_poll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -33,7 +33,7 @@
 #include "asio/detail/timer_queue_base.hpp"
 #include "asio/detail/timer_queue_set.hpp"
 #include "asio/detail/wait_op.hpp"
-#include "asio/io_service.hpp"
+#include "asio/execution_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -41,7 +41,7 @@ namespace asio {
 namespace detail {
 
 class dev_poll_reactor
-  : public asio::detail::service_base<dev_poll_reactor>
+  : public execution_context_service_base<dev_poll_reactor>
 {
 public:
   enum op_types { read_op = 0, write_op = 1,
@@ -53,17 +53,17 @@ class dev_poll_reactor
   };
 
   // Constructor.
-  ASIO_DECL dev_poll_reactor(asio::io_service& io_service);
+  ASIO_DECL dev_poll_reactor(asio::execution_context& ctx);
 
   // Destructor.
   ASIO_DECL ~dev_poll_reactor();
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Recreate internal descriptors following a fork.
-  ASIO_DECL void fork_service(
-      asio::io_service::fork_event fork_ev);
+  ASIO_DECL void notify_fork(
+      asio::execution_context::fork_event fork_ev);
 
   // Initialise the task.
   ASIO_DECL void init_task();
@@ -86,7 +86,7 @@ class dev_poll_reactor
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op, is_continuation);
+    scheduler_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
@@ -101,15 +101,21 @@ class dev_poll_reactor
   ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
   // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor.
+  // its registration from the reactor. The reactor resources associated with
+  // the descriptor must be released by calling cleanup_descriptor_data.
   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.
+  // Remove the descriptor's registration from the reactor. The reactor
+  // resources associated with the descriptor must be released by calling
+  // cleanup_descriptor_data.
   ASIO_DECL void deregister_internal_descriptor(
       socket_type descriptor, per_descriptor_data&);
 
+  // Perform any post-deregistration cleanup tasks associated with the
+  // descriptor data.
+  ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&);
+
   // Add a new timer queue to the reactor.
   template <typename Time_Traits>
   void add_timer_queue(timer_queue<Time_Traits>& queue);
@@ -132,8 +138,14 @@ class dev_poll_reactor
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Move the timer operations associated with the given timer.
+  template <typename Time_Traits>
+  void move_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& target,
+      typename timer_queue<Time_Traits>::per_timer_data& source);
+
   // Run /dev/poll once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(bool block, op_queue<operation>& ops);
+  ASIO_DECL void run(long usec, op_queue<operation>& ops);
 
   // Interrupt the select loop.
   ASIO_DECL void interrupt();
@@ -152,7 +164,7 @@ class dev_poll_reactor
   // Get the timeout value for the /dev/poll DP_POLL operation. The timeout
   // value is returned as a number of milliseconds. A return value of -1
   // indicates that the poll should block indefinitely.
-  ASIO_DECL int get_timeout();
+  ASIO_DECL int get_timeout(int msec);
 
   // Cancel all operations associated with the given descriptor. The do_cancel
   // function of the handler objects will be invoked. This function does not
@@ -163,8 +175,8 @@ class dev_poll_reactor
   // Add a pending event entry for the given descriptor.
   ASIO_DECL ::pollfd& add_pending_event_change(int descriptor);
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
+  // The scheduler implementation used to post completions.
+  scheduler& scheduler_;
 
   // Mutex to protect access to internal data.
   asio::detail::mutex mutex_;
diff --git a/extern/include/asio/detail/epoll_reactor.hpp b/extern/include/asio/detail/epoll_reactor.hpp
index 4714661b..5f581099 100644
--- a/extern/include/asio/detail/epoll_reactor.hpp
+++ b/extern/include/asio/detail/epoll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/epoll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,10 +19,9 @@
 
 #if defined(ASIO_HAS_EPOLL)
 
-#include "asio/io_service.hpp"
 #include "asio/detail/atomic_count.hpp"
+#include "asio/detail/conditionally_enabled_mutex.hpp"
 #include "asio/detail/limits.hpp"
-#include "asio/detail/mutex.hpp"
 #include "asio/detail/object_pool.hpp"
 #include "asio/detail/op_queue.hpp"
 #include "asio/detail/reactor_op.hpp"
@@ -31,6 +30,11 @@
 #include "asio/detail/timer_queue_base.hpp"
 #include "asio/detail/timer_queue_set.hpp"
 #include "asio/detail/wait_op.hpp"
+#include "asio/execution_context.hpp"
+
+#if defined(ASIO_HAS_TIMERFD)
+# include <sys/timerfd.h>
+#endif // defined(ASIO_HAS_TIMERFD)
 
 #include "asio/detail/push_options.hpp"
 
@@ -38,8 +42,12 @@ namespace asio {
 namespace detail {
 
 class epoll_reactor
-  : public asio::detail::service_base<epoll_reactor>
+  : public execution_context_service_base<epoll_reactor>
 {
+private:
+  // The mutex type used by this reactor.
+  typedef conditionally_enabled_mutex mutex;
+
 public:
   enum op_types { read_op = 0, write_op = 1,
     connect_op = 1, except_op = 2, max_ops = 3 };
@@ -58,13 +66,15 @@ class epoll_reactor
     int descriptor_;
     uint32_t registered_events_;
     op_queue<reactor_op> op_queue_[max_ops];
+    bool try_speculative_[max_ops];
     bool shutdown_;
 
-    ASIO_DECL descriptor_state();
+    ASIO_DECL descriptor_state(bool locking);
     void set_ready_events(uint32_t events) { task_result_ = events; }
+    void add_ready_events(uint32_t events) { task_result_ |= events; }
     ASIO_DECL operation* perform_io(uint32_t events);
     ASIO_DECL static void do_complete(
-        io_service_impl* owner, operation* base,
+        void* owner, operation* base,
         const asio::error_code& ec, std::size_t bytes_transferred);
   };
 
@@ -72,17 +82,17 @@ class epoll_reactor
   typedef descriptor_state* per_descriptor_data;
 
   // Constructor.
-  ASIO_DECL epoll_reactor(asio::io_service& io_service);
+  ASIO_DECL epoll_reactor(asio::execution_context& ctx);
 
   // Destructor.
   ASIO_DECL ~epoll_reactor();
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Recreate internal descriptors following a fork.
-  ASIO_DECL void fork_service(
-      asio::io_service::fork_event fork_ev);
+  ASIO_DECL void notify_fork(
+      asio::execution_context::fork_event fork_ev);
 
   // Initialise the task.
   ASIO_DECL void init_task();
@@ -106,7 +116,7 @@ class epoll_reactor
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op, is_continuation);
+    scheduler_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
@@ -122,14 +132,22 @@ class epoll_reactor
       per_descriptor_data& descriptor_data);
 
   // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor.
+  // its registration from the reactor. The reactor resources associated with
+  // the descriptor must be released by calling cleanup_descriptor_data.
   ASIO_DECL void deregister_descriptor(socket_type descriptor,
       per_descriptor_data& descriptor_data, bool closing);
 
-  // Remote the descriptor's registration from the reactor.
+  // Remove the descriptor's registration from the reactor. The reactor
+  // resources associated with the descriptor must be released by calling
+  // cleanup_descriptor_data.
   ASIO_DECL void deregister_internal_descriptor(
       socket_type descriptor, per_descriptor_data& descriptor_data);
 
+  // Perform any post-deregistration cleanup tasks associated with the
+  // descriptor data.
+  ASIO_DECL void cleanup_descriptor_data(
+      per_descriptor_data& descriptor_data);
+
   // Add a new timer queue to the reactor.
   template <typename Time_Traits>
   void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
@@ -152,8 +170,14 @@ class epoll_reactor
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Move the timer operations associated with the given timer.
+  template <typename Time_Traits>
+  void move_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& target,
+      typename timer_queue<Time_Traits>::per_timer_data& source);
+
   // Run epoll once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(bool block, op_queue<operation>& ops);
+  ASIO_DECL void run(long usec, op_queue<operation>& ops);
 
   // Interrupt the select loop.
   ASIO_DECL void interrupt();
@@ -187,7 +211,7 @@ class epoll_reactor
   // Get the timeout value for the epoll_wait call. The timeout value is
   // returned as a number of milliseconds. A return value of -1 indicates
   // that epoll_wait should block indefinitely.
-  ASIO_DECL int get_timeout();
+  ASIO_DECL int get_timeout(int msec);
 
 #if defined(ASIO_HAS_TIMERFD)
   // Get the timeout value for the timer descriptor. The return value is the
@@ -195,8 +219,8 @@ class epoll_reactor
   ASIO_DECL int get_timeout(itimerspec& ts);
 #endif // defined(ASIO_HAS_TIMERFD)
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
+  // The scheduler implementation used to post completions.
+  scheduler& scheduler_;
 
   // Mutex to protect access to internal data.
   mutex mutex_;
diff --git a/extern/include/asio/detail/event.hpp b/extern/include/asio/detail/event.hpp
index 2f6934c0..da8fa770 100644
--- a/extern/include/asio/detail/event.hpp
+++ b/extern/include/asio/detail/event.hpp
@@ -2,7 +2,7 @@
 // detail/event.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/eventfd_select_interrupter.hpp b/extern/include/asio/detail/eventfd_select_interrupter.hpp
index daa43895..f6e594b6 100644
--- a/extern/include/asio/detail/eventfd_select_interrupter.hpp
+++ b/extern/include/asio/detail/eventfd_select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/eventfd_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/extern/include/asio/detail/executor_op.hpp b/extern/include/asio/detail/executor_op.hpp
new file mode 100644
index 00000000..2d5c7e8b
--- /dev/null
+++ b/extern/include/asio/detail/executor_op.hpp
@@ -0,0 +1,84 @@
+//
+// detail/executor_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_EXECUTOR_OP_HPP
+#define ASIO_DETAIL_EXECUTOR_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/scheduler_operation.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename Alloc,
+    typename Operation = scheduler_operation>
+class executor_op : public Operation
+{
+public:
+  ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(executor_op);
+
+  template <typename H>
+  executor_op(ASIO_MOVE_ARG(H) h, const Alloc& allocator)
+    : Operation(&executor_op::do_complete),
+      handler_(ASIO_MOVE_CAST(H)(h)),
+      allocator_(allocator)
+  {
+  }
+
+  static void do_complete(void* owner, Operation* base,
+      const asio::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    executor_op* o(static_cast<executor_op*>(base));
+    Alloc allocator(o->allocator_);
+    ptr p = { detail::addressof(allocator), o, o };
+
+    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.
+    Handler handler(ASIO_MOVE_CAST(Handler)(o->handler_));
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      ASIO_HANDLER_INVOCATION_BEGIN(());
+      asio_handler_invoke_helpers::invoke(handler, handler);
+      ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  Alloc allocator_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_EXECUTOR_OP_HPP
diff --git a/extern/include/asio/detail/fd_set_adapter.hpp b/extern/include/asio/detail/fd_set_adapter.hpp
index 661f145b..fd373dae 100644
--- a/extern/include/asio/detail/fd_set_adapter.hpp
+++ b/extern/include/asio/detail/fd_set_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/fenced_block.hpp b/extern/include/asio/detail/fenced_block.hpp
index 6b5a60e3..dc34bd9f 100644
--- a/extern/include/asio/detail/fenced_block.hpp
+++ b/extern/include/asio/detail/fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,8 @@
 #if !defined(ASIO_HAS_THREADS) \
   || defined(ASIO_DISABLE_FENCED_BLOCK)
 # include "asio/detail/null_fenced_block.hpp"
+#elif defined(ASIO_HAS_STD_ATOMIC)
+# include "asio/detail/std_fenced_block.hpp"
 #elif defined(__MACH__) && defined(__APPLE__)
 # include "asio/detail/macos_fenced_block.hpp"
 #elif defined(__sun)
@@ -48,6 +50,8 @@ namespace detail {
 #if !defined(ASIO_HAS_THREADS) \
   || defined(ASIO_DISABLE_FENCED_BLOCK)
 typedef null_fenced_block fenced_block;
+#elif defined(ASIO_HAS_STD_ATOMIC)
+typedef std_fenced_block fenced_block;
 #elif defined(__MACH__) && defined(__APPLE__)
 typedef macos_fenced_block fenced_block;
 #elif defined(__sun)
diff --git a/extern/include/asio/detail/function.hpp b/extern/include/asio/detail/functional.hpp
similarity index 63%
rename from extern/include/asio/detail/function.hpp
rename to extern/include/asio/detail/functional.hpp
index 4b44bfba..a37e9e63 100644
--- a/extern/include/asio/detail/function.hpp
+++ b/extern/include/asio/detail/functional.hpp
@@ -1,15 +1,15 @@
 //
-// detail/function.hpp
-// ~~~~~~~~~~~~~~~~~~~
+// detail/functional.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_FUNCTION_HPP
-#define ASIO_DETAIL_FUNCTION_HPP
+#ifndef ASIO_DETAIL_FUNCTIONAL_HPP
+#define ASIO_DETAIL_FUNCTIONAL_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,11 +17,11 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_HAS_STD_FUNCTION)
-# include <functional>
-#else // defined(ASIO_HAS_STD_FUNCTION)
+#include <functional>
+
+#if !defined(ASIO_HAS_STD_FUNCTION)
 # include <boost/function.hpp>
-#endif // defined(ASIO_HAS_STD_FUNCTION)
+#endif // !defined(ASIO_HAS_STD_FUNCTION)
 
 namespace asio {
 namespace detail {
@@ -35,4 +35,4 @@ using boost::function;
 } // namespace detail
 } // namespace asio
 
-#endif // ASIO_DETAIL_FUNCTION_HPP
+#endif // ASIO_DETAIL_FUNCTIONAL_HPP
diff --git a/extern/include/asio/detail/gcc_arm_fenced_block.hpp b/extern/include/asio/detail/gcc_arm_fenced_block.hpp
index b7fecb40..7919a551 100644
--- a/extern/include/asio/detail/gcc_arm_fenced_block.hpp
+++ b/extern/include/asio/detail/gcc_arm_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_arm_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,8 @@
 
 #if defined(__GNUC__) && defined(__arm__)
 
+#include "asio/detail/noncopyable.hpp"
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
diff --git a/extern/include/asio/detail/gcc_hppa_fenced_block.hpp b/extern/include/asio/detail/gcc_hppa_fenced_block.hpp
index 79527bc7..d3957ce3 100644
--- a/extern/include/asio/detail/gcc_hppa_fenced_block.hpp
+++ b/extern/include/asio/detail/gcc_hppa_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_hppa_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,8 @@
 
 #if defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
 
+#include "asio/detail/noncopyable.hpp"
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
diff --git a/extern/include/asio/detail/gcc_sync_fenced_block.hpp b/extern/include/asio/detail/gcc_sync_fenced_block.hpp
index db4efcbd..90d176f1 100644
--- a/extern/include/asio/detail/gcc_sync_fenced_block.hpp
+++ b/extern/include/asio/detail/gcc_sync_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_sync_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,6 +22,8 @@
   && !defined(__INTEL_COMPILER) && !defined(__ICL) \
   && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
 
+#include "asio/detail/noncopyable.hpp"
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
diff --git a/extern/include/asio/detail/gcc_x86_fenced_block.hpp b/extern/include/asio/detail/gcc_x86_fenced_block.hpp
index 8f278833..1366def7 100644
--- a/extern/include/asio/detail/gcc_x86_fenced_block.hpp
+++ b/extern/include/asio/detail/gcc_x86_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_x86_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,8 @@
 
 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 
+#include "asio/detail/noncopyable.hpp"
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
diff --git a/extern/include/asio/detail/global.hpp b/extern/include/asio/detail/global.hpp
new file mode 100644
index 00000000..085ac643
--- /dev/null
+++ b/extern/include/asio/detail/global.hpp
@@ -0,0 +1,52 @@
+//
+// detail/global.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_GLOBAL_HPP
+#define ASIO_DETAIL_GLOBAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_HAS_THREADS)
+# include "asio/detail/null_global.hpp"
+#elif defined(ASIO_WINDOWS)
+# include "asio/detail/win_global.hpp"
+#elif defined(ASIO_HAS_PTHREADS)
+# include "asio/detail/posix_global.hpp"
+#elif defined(ASIO_HAS_STD_CALL_ONCE)
+# include "asio/detail/std_global.hpp"
+#else
+# error Only Windows, POSIX and std::call_once are supported!
+#endif
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+inline T& global()
+{
+#if !defined(ASIO_HAS_THREADS)
+  return null_global<T>();
+#elif defined(ASIO_WINDOWS)
+  return win_global<T>();
+#elif defined(ASIO_HAS_PTHREADS)
+  return posix_global<T>();
+#elif defined(ASIO_HAS_STD_CALL_ONCE)
+  return std_global<T>();
+#endif
+}
+
+} // namespace detail
+} // namespace asio
+
+#endif // ASIO_DETAIL_GLOBAL_HPP
diff --git a/extern/include/asio/detail/handler_alloc_helpers.hpp b/extern/include/asio/detail/handler_alloc_helpers.hpp
index 974158b9..afefb4d1 100644
--- a/extern/include/asio/detail/handler_alloc_helpers.hpp
+++ b/extern/include/asio/detail/handler_alloc_helpers.hpp
@@ -2,7 +2,7 @@
 // detail/handler_alloc_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,8 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
+#include "asio/detail/recycling_allocator.hpp"
+#include "asio/associated_allocator.hpp"
 #include "asio/handler_alloc_hook.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -51,16 +53,163 @@ inline void deallocate(void* p, std::size_t s, Handler& h)
 
 } // namespace asio_handler_alloc_helpers
 
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename T>
+class hook_allocator
+{
+public:
+  typedef T value_type;
+
+  template <typename U>
+  struct rebind
+  {
+    typedef hook_allocator<Handler, U> other;
+  };
+
+  explicit hook_allocator(Handler& h)
+    : handler_(h)
+  {
+  }
+
+  template <typename U>
+  hook_allocator(const hook_allocator<Handler, U>& a)
+    : handler_(a.handler_)
+  {
+  }
+
+  T* allocate(std::size_t n)
+  {
+    return static_cast<T*>(
+        asio_handler_alloc_helpers::allocate(sizeof(T) * n, handler_));
+  }
+
+  void deallocate(T* p, std::size_t n)
+  {
+    asio_handler_alloc_helpers::deallocate(p, sizeof(T) * n, handler_);
+  }
+
+//private:
+  Handler& handler_;
+};
+
+template <typename Handler>
+class hook_allocator<Handler, void>
+{
+public:
+  typedef void value_type;
+
+  template <typename U>
+  struct rebind
+  {
+    typedef hook_allocator<Handler, U> other;
+  };
+
+  explicit hook_allocator(Handler& h)
+    : handler_(h)
+  {
+  }
+
+  template <typename U>
+  hook_allocator(const hook_allocator<Handler, U>& a)
+    : handler_(a.handler_)
+  {
+  }
+
+//private:
+  Handler& handler_;
+};
+
+template <typename Handler, typename Allocator>
+struct get_hook_allocator
+{
+  typedef Allocator type;
+
+  static type get(Handler&, const Allocator& a)
+  {
+    return a;
+  }
+};
+
+template <typename Handler, typename T>
+struct get_hook_allocator<Handler, std::allocator<T> >
+{
+  typedef hook_allocator<Handler, T> type;
+
+  static type get(Handler& handler, const std::allocator<T>&)
+  {
+    return type(handler);
+  }
+};
+
+} // namespace detail
+} // namespace asio
+
 #define ASIO_DEFINE_HANDLER_PTR(op) \
   struct ptr \
   { \
     Handler* h; \
+    op* v; \
+    op* p; \
+    ~ptr() \
+    { \
+      reset(); \
+    } \
+    static op* allocate(Handler& handler) \
+    { \
+      typedef typename ::asio::associated_allocator< \
+        Handler>::type associated_allocator_type; \
+      typedef typename ::asio::detail::get_hook_allocator< \
+        Handler, associated_allocator_type>::type hook_allocator_type; \
+      ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \
+            ::asio::detail::get_hook_allocator< \
+              Handler, associated_allocator_type>::get( \
+                handler, ::asio::get_associated_allocator(handler))); \
+      return a.allocate(1); \
+    } \
+    void reset() \
+    { \
+      if (p) \
+      { \
+        p->~op(); \
+        p = 0; \
+      } \
+      if (v) \
+      { \
+        typedef typename ::asio::associated_allocator< \
+          Handler>::type associated_allocator_type; \
+        typedef typename ::asio::detail::get_hook_allocator< \
+          Handler, associated_allocator_type>::type hook_allocator_type; \
+        ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \
+              ::asio::detail::get_hook_allocator< \
+                Handler, associated_allocator_type>::get( \
+                  *h, ::asio::get_associated_allocator(*h))); \
+        a.deallocate(static_cast<op*>(v), 1); \
+        v = 0; \
+      } \
+    } \
+  } \
+  /**/
+
+#define ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(op) \
+  struct ptr \
+  { \
+    const Alloc* a; \
     void* v; \
     op* p; \
     ~ptr() \
     { \
       reset(); \
     } \
+    static op* allocate(const Alloc& a) \
+    { \
+      typedef typename ::asio::detail::get_recycling_allocator< \
+        Alloc>::type recycling_allocator_type; \
+      ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \
+            ::asio::detail::get_recycling_allocator<Alloc>::get(a)); \
+      return a1.allocate(1); \
+    } \
     void reset() \
     { \
       if (p) \
@@ -70,7 +219,11 @@ inline void deallocate(void* p, std::size_t s, Handler& h)
       } \
       if (v) \
       { \
-        asio_handler_alloc_helpers::deallocate(v, sizeof(op), *h); \
+        typedef typename ::asio::detail::get_recycling_allocator< \
+          Alloc>::type recycling_allocator_type; \
+        ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \
+              ::asio::detail::get_recycling_allocator<Alloc>::get(*a)); \
+        a1.deallocate(static_cast<op*>(v), 1); \
         v = 0; \
       } \
     } \
diff --git a/extern/include/asio/detail/handler_cont_helpers.hpp b/extern/include/asio/detail/handler_cont_helpers.hpp
index 8b7c42e7..110ba944 100644
--- a/extern/include/asio/detail/handler_cont_helpers.hpp
+++ b/extern/include/asio/detail/handler_cont_helpers.hpp
@@ -2,7 +2,7 @@
 // detail/handler_cont_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/handler_continuation_hook.hpp"
 
 #include "asio/detail/push_options.hpp"
diff --git a/extern/include/asio/detail/handler_invoke_helpers.hpp b/extern/include/asio/detail/handler_invoke_helpers.hpp
index 47ad6847..4c65c4c5 100644
--- a/extern/include/asio/detail/handler_invoke_helpers.hpp
+++ b/extern/include/asio/detail/handler_invoke_helpers.hpp
@@ -2,7 +2,7 @@
 // detail/handler_invoke_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/handler_invoke_hook.hpp"
 
 #include "asio/detail/push_options.hpp"
diff --git a/extern/include/asio/detail/handler_tracking.hpp b/extern/include/asio/detail/handler_tracking.hpp
index 14e81771..83f820ec 100644
--- a/extern/include/asio/detail/handler_tracking.hpp
+++ b/extern/include/asio/detail/handler_tracking.hpp
@@ -2,7 +2,7 @@
 // detail/handler_tracking.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,7 +17,15 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
+namespace asio {
+
+class execution_context;
+
+} // namespace asio
+
+#if defined(ASIO_CUSTOM_HANDLER_TRACKING)
+# include ASIO_CUSTOM_HANDLER_TRACKING
+#elif defined(ASIO_ENABLE_HANDLER_TRACKING)
 # include "asio/error_code.hpp"
 # include "asio/detail/cstdint.hpp"
 # include "asio/detail/static_mutex.hpp"
@@ -29,7 +37,30 @@
 namespace asio {
 namespace detail {
 
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
+#if defined(ASIO_CUSTOM_HANDLER_TRACKING)
+
+// The user-specified header must define the following macros:
+// - ASIO_INHERIT_TRACKED_HANDLER
+// - ASIO_ALSO_INHERIT_TRACKED_HANDLER
+// - ASIO_HANDLER_TRACKING_INIT
+// - ASIO_HANDLER_CREATION(args)
+// - ASIO_HANDLER_COMPLETION(args)
+// - ASIO_HANDLER_INVOCATION_BEGIN(args)
+// - ASIO_HANDLER_INVOCATION_END
+// - ASIO_HANDLER_OPERATION(args)
+// - ASIO_HANDLER_REACTOR_REGISTRATION(args)
+// - ASIO_HANDLER_REACTOR_DEREGISTRATION(args)
+// - ASIO_HANDLER_REACTOR_READ_EVENT
+// - ASIO_HANDLER_REACTOR_WRITE_EVENT
+// - ASIO_HANDLER_REACTOR_ERROR_EVENT
+// - ASIO_HANDLER_REACTOR_EVENTS(args)
+// - ASIO_HANDLER_REACTOR_OPERATION(args)
+
+# if !defined(ASIO_ENABLE_HANDLER_TRACKING)
+#  define ASIO_ENABLE_HANDLER_TRACKING 1
+# endif /// !defined(ASIO_ENABLE_HANDLER_TRACKING)
+
+#elif defined(ASIO_ENABLE_HANDLER_TRACKING)
 
 class handler_tracking
 {
@@ -57,14 +88,16 @@ class handler_tracking
   ASIO_DECL static void init();
 
   // Record the creation of a tracked handler.
-  ASIO_DECL static void creation(tracked_handler* h,
-      const char* object_type, void* object, const char* op_name);
+  ASIO_DECL static void creation(
+      execution_context& context, tracked_handler& h,
+      const char* object_type, void* object,
+      uintmax_t native_handle, const char* op_name);
 
   class completion
   {
   public:
     // Constructor records that handler is to be invoked with no arguments.
-    ASIO_DECL explicit completion(tracked_handler* h);
+    ASIO_DECL explicit completion(const 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.
@@ -98,9 +131,32 @@ class handler_tracking
     completion* next_;
   };
 
-  // Record an operation that affects pending handlers.
-  ASIO_DECL static void operation(const char* object_type,
-      void* object, const char* op_name);
+  // Record an operation that is not directly associated with a handler.
+  ASIO_DECL static void operation(execution_context& context,
+      const char* object_type, void* object,
+      uintmax_t native_handle, const char* op_name);
+
+  // Record that a descriptor has been registered with the reactor.
+  ASIO_DECL static void reactor_registration(execution_context& context,
+      uintmax_t native_handle, uintmax_t registration);
+
+  // Record that a descriptor has been deregistered from the reactor.
+  ASIO_DECL static void reactor_deregistration(execution_context& context,
+      uintmax_t native_handle, uintmax_t registration);
+
+  // Record a reactor-based operation that is associated with a handler.
+  ASIO_DECL static void reactor_events(execution_context& context,
+      uintmax_t registration, unsigned events);
+
+  // Record a reactor-based operation that is associated with a handler.
+  ASIO_DECL static void reactor_operation(
+      const tracked_handler& h, const char* op_name,
+      const asio::error_code& ec);
+
+  // Record a reactor-based operation that is associated with a handler.
+  ASIO_DECL static void reactor_operation(
+      const tracked_handler& h, const char* op_name,
+      const asio::error_code& ec, std::size_t bytes_transferred);
 
   // Write a line of output.
   ASIO_DECL static void write_line(const char* format, ...);
@@ -134,6 +190,22 @@ class handler_tracking
 # define ASIO_HANDLER_OPERATION(args) \
   asio::detail::handler_tracking::operation args
 
+# define ASIO_HANDLER_REACTOR_REGISTRATION(args) \
+  asio::detail::handler_tracking::reactor_registration args
+
+# define ASIO_HANDLER_REACTOR_DEREGISTRATION(args) \
+  asio::detail::handler_tracking::reactor_deregistration args
+
+# define ASIO_HANDLER_REACTOR_READ_EVENT 1
+# define ASIO_HANDLER_REACTOR_WRITE_EVENT 2
+# define ASIO_HANDLER_REACTOR_ERROR_EVENT 4
+
+# define ASIO_HANDLER_REACTOR_EVENTS(args) \
+  asio::detail::handler_tracking::reactor_events args
+
+# define ASIO_HANDLER_REACTOR_OPERATION(args) \
+  asio::detail::handler_tracking::reactor_operation args
+
 #else // defined(ASIO_ENABLE_HANDLER_TRACKING)
 
 # define ASIO_INHERIT_TRACKED_HANDLER
@@ -144,6 +216,13 @@ class handler_tracking
 # define ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0
 # define ASIO_HANDLER_INVOCATION_END (void)0
 # define ASIO_HANDLER_OPERATION(args) (void)0
+# define ASIO_HANDLER_REACTOR_REGISTRATION(args) (void)0
+# define ASIO_HANDLER_REACTOR_DEREGISTRATION(args) (void)0
+# define ASIO_HANDLER_REACTOR_READ_EVENT 0
+# define ASIO_HANDLER_REACTOR_WRITE_EVENT 0
+# define ASIO_HANDLER_REACTOR_ERROR_EVENT 0
+# define ASIO_HANDLER_REACTOR_EVENTS(args) (void)0
+# define ASIO_HANDLER_REACTOR_OPERATION(args) (void)0
 
 #endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
 
diff --git a/extern/include/asio/detail/handler_type_requirements.hpp b/extern/include/asio/detail/handler_type_requirements.hpp
index 9eb2ceac..9181bc51 100644
--- a/extern/include/asio/detail/handler_type_requirements.hpp
+++ b/extern/include/asio/detail/handler_type_requirements.hpp
@@ -2,7 +2,7 @@
 // detail/handler_type_requirements.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -50,19 +50,9 @@
 #endif // !defined(ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
 
 #if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-# include "asio/handler_type.hpp"
+# include "asio/async_result.hpp"
 #endif // defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 
-// Newer gcc needs special treatment to suppress unused typedef warnings.
-#if defined(__GNUC__)
-# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
-#  define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
-# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
-#endif // defined(__GNUC__)
-#if !defined(ASIO_UNUSED_TYPEDEF)
-# define ASIO_UNUSED_TYPEDEF
-#endif // !defined(ASIO_UNUSED_TYPEDEF)
-
 namespace asio {
 namespace detail {
 
@@ -71,19 +61,19 @@ namespace detail {
 # if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
 
 template <typename Handler>
-auto zero_arg_handler_test(Handler h, void*)
+auto zero_arg_copyable_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];
+char (&zero_arg_copyable_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))),
+    sizeof(Handler(ASIO_MOVE_CAST(Handler)(h))),
     ((h)(*a1)),
     char(0));
 
@@ -93,13 +83,23 @@ 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))),
+    sizeof(Handler(ASIO_MOVE_CAST(Handler)(h))),
     ((h)(*a1, *a2)),
     char(0));
 
 template <typename Handler>
 char (&two_arg_handler_test(Handler, ...))[2];
 
+template <typename Handler, typename Arg1, typename Arg2>
+auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2)
+  -> decltype(
+    sizeof(Handler(ASIO_MOVE_CAST(Handler)(h))),
+    ((h)(*a1, ASIO_MOVE_CAST(Arg2)(*a2))),
+    char(0));
+
+template <typename Handler>
+char (&two_arg_move_handler_test(Handler, ...))[2];
+
 #  define ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \
      static_assert(expr, msg);
 
@@ -113,6 +113,13 @@ template <typename T> T& lvref();
 template <typename T> T& lvref(T);
 template <typename T> const T& clvref();
 template <typename T> const T& clvref(T);
+#if defined(ASIO_HAS_MOVE)
+template <typename T> T rvref();
+template <typename T> T rvref(T);
+#else // defined(ASIO_HAS_MOVE)
+template <typename T> const T& rvref();
+template <typename T> const T& rvref(T);
+#endif // defined(ASIO_HAS_MOVE)
 template <typename T> char argbyv(T);
 
 template <int>
@@ -120,14 +127,14 @@ struct handler_type_requirements
 {
 };
 
-#define ASIO_COMPLETION_HANDLER_CHECK( \
+#define ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \
     handler_type, handler) \
   \
   typedef ASIO_HANDLER_TYPE(handler_type, \
       void()) asio_true_handler_type; \
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::zero_arg_handler_test( \
+      sizeof(asio::detail::zero_arg_copyable_handler_test( \
           asio::detail::clvref< \
             asio_true_handler_type>(), 0)) == 1, \
       "CompletionHandler type requirements not met") \
@@ -151,7 +158,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0), \
           static_cast<const std::size_t*>(0))) == 1, \
@@ -160,7 +167,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -169,7 +176,6 @@ struct handler_type_requirements
             asio::detail::lvref<const std::size_t>()), \
         char(0))> ASIO_UNUSED_TYPEDEF
 
-
 #define ASIO_WRITE_HANDLER_CHECK( \
     handler_type, handler) \
   \
@@ -179,7 +185,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0), \
           static_cast<const std::size_t*>(0))) == 1, \
@@ -188,7 +194,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -206,7 +212,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0))) == 1, \
       "AcceptHandler type requirements not met") \
@@ -214,7 +220,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -222,6 +228,33 @@ struct handler_type_requirements
             asio::detail::lvref<const asio::error_code>()), \
         char(0))> ASIO_UNUSED_TYPEDEF
 
+#define ASIO_MOVE_ACCEPT_HANDLER_CHECK( \
+    handler_type, handler, socket_type) \
+  \
+  typedef ASIO_HANDLER_TYPE(handler_type, \
+      void(asio::error_code, socket_type)) \
+    asio_true_handler_type; \
+  \
+  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(asio::detail::two_arg_move_handler_test( \
+          asio::detail::rvref< \
+            asio_true_handler_type>(), \
+          static_cast<const asio::error_code*>(0), \
+          static_cast<socket_type*>(0))) == 1, \
+      "MoveAcceptHandler type requirements not met") \
+  \
+  typedef asio::detail::handler_type_requirements< \
+      sizeof( \
+        asio::detail::argbyv( \
+          asio::detail::rvref< \
+            asio_true_handler_type>())) + \
+      sizeof( \
+        asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            asio::detail::lvref<const asio::error_code>(), \
+            asio::detail::rvref<socket_type>()), \
+        char(0))> ASIO_UNUSED_TYPEDEF
+
 #define ASIO_CONNECT_HANDLER_CHECK( \
     handler_type, handler) \
   \
@@ -231,7 +264,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0))) == 1, \
       "ConnectHandler type requirements not met") \
@@ -239,7 +272,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -247,7 +280,34 @@ struct handler_type_requirements
             asio::detail::lvref<const asio::error_code>()), \
         char(0))> ASIO_UNUSED_TYPEDEF
 
-#define ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
+#define ASIO_RANGE_CONNECT_HANDLER_CHECK( \
+    handler_type, handler, endpoint_type) \
+  \
+  typedef ASIO_HANDLER_TYPE(handler_type, \
+      void(asio::error_code, endpoint_type)) \
+    asio_true_handler_type; \
+  \
+  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(asio::detail::two_arg_handler_test( \
+          asio::detail::rvref< \
+            asio_true_handler_type>(), \
+          static_cast<const asio::error_code*>(0), \
+          static_cast<const endpoint_type*>(0))) == 1, \
+      "RangeConnectHandler type requirements not met") \
+  \
+  typedef asio::detail::handler_type_requirements< \
+      sizeof( \
+        asio::detail::argbyv( \
+          asio::detail::rvref< \
+            asio_true_handler_type>())) + \
+      sizeof( \
+        asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            asio::detail::lvref<const asio::error_code>(), \
+            asio::detail::lvref<const endpoint_type>()), \
+        char(0))> ASIO_UNUSED_TYPEDEF
+
+#define ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \
     handler_type, handler, iter_type) \
   \
   typedef ASIO_HANDLER_TYPE(handler_type, \
@@ -256,16 +316,16 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0), \
           static_cast<const iter_type*>(0))) == 1, \
-      "ComposedConnectHandler type requirements not met") \
+      "IteratorConnectHandler type requirements not met") \
   \
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -275,30 +335,30 @@ struct handler_type_requirements
         char(0))> ASIO_UNUSED_TYPEDEF
 
 #define ASIO_RESOLVE_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
+    handler_type, handler, range_type) \
   \
   typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, iter_type)) \
+      void(asio::error_code, range_type)) \
     asio_true_handler_type; \
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0), \
-          static_cast<const iter_type*>(0))) == 1, \
+          static_cast<const range_type*>(0))) == 1, \
       "ResolveHandler type requirements not met") \
   \
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
           asio_true_handler_type>()( \
             asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::lvref<const iter_type>()), \
+            asio::detail::lvref<const range_type>()), \
         char(0))> ASIO_UNUSED_TYPEDEF
 
 #define ASIO_WAIT_HANDLER_CHECK( \
@@ -310,7 +370,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0))) == 1, \
       "WaitHandler type requirements not met") \
@@ -318,7 +378,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -335,7 +395,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0), \
           static_cast<const int*>(0))) == 1, \
@@ -344,7 +404,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -362,7 +422,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0))) == 1, \
       "HandshakeHandler type requirements not met") \
@@ -370,7 +430,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -387,7 +447,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0), \
           static_cast<const std::size_t*>(0))) == 1, \
@@ -396,7 +456,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -414,7 +474,7 @@ struct handler_type_requirements
   \
   ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>(), \
           static_cast<const asio::error_code*>(0))) == 1, \
       "ShutdownHandler type requirements not met") \
@@ -422,7 +482,7 @@ struct handler_type_requirements
   typedef asio::detail::handler_type_requirements< \
       sizeof( \
         asio::detail::argbyv( \
-          asio::detail::clvref< \
+          asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
         asio::detail::lvref< \
@@ -432,7 +492,7 @@ struct handler_type_requirements
 
 #else // !defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 
-#define ASIO_COMPLETION_HANDLER_CHECK( \
+#define ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \
     handler_type, handler) \
   typedef int ASIO_UNUSED_TYPEDEF
 
@@ -448,11 +508,19 @@ struct handler_type_requirements
     handler_type, handler) \
   typedef int ASIO_UNUSED_TYPEDEF
 
+#define ASIO_MOVE_ACCEPT_HANDLER_CHECK( \
+    handler_type, handler, socket_type) \
+  typedef int ASIO_UNUSED_TYPEDEF
+
 #define ASIO_CONNECT_HANDLER_CHECK( \
     handler_type, handler) \
   typedef int ASIO_UNUSED_TYPEDEF
 
-#define ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
+#define ASIO_RANGE_CONNECT_HANDLER_CHECK( \
+    handler_type, handler, iter_type) \
+  typedef int ASIO_UNUSED_TYPEDEF
+
+#define ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \
     handler_type, handler, iter_type) \
   typedef int ASIO_UNUSED_TYPEDEF
 
diff --git a/extern/include/asio/detail/handler_work.hpp b/extern/include/asio/detail/handler_work.hpp
new file mode 100644
index 00000000..cce5c4b6
--- /dev/null
+++ b/extern/include/asio/detail/handler_work.hpp
@@ -0,0 +1,95 @@
+//
+// detail/handler_work.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_HANDLER_WORK_HPP
+#define ASIO_DETAIL_HANDLER_WORK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+// A helper class template to allow completion handlers to be dispatched
+// through either the new executors framework or the old invocaton hook. The
+// primary template uses the new executors framework.
+template <typename Handler, typename Executor
+    = typename associated_executor<Handler>::type>
+class handler_work
+{
+public:
+  explicit handler_work(Handler& handler) ASIO_NOEXCEPT
+    : executor_(associated_executor<Handler>::get(handler))
+  {
+  }
+
+  static void start(Handler& handler) ASIO_NOEXCEPT
+  {
+    Executor ex(associated_executor<Handler>::get(handler));
+    ex.on_work_started();
+  }
+
+  ~handler_work()
+  {
+    executor_.on_work_finished();
+  }
+
+  template <typename Function>
+  void complete(Function& function, Handler& handler)
+  {
+    executor_.dispatch(ASIO_MOVE_CAST(Function)(function),
+        associated_allocator<Handler>::get(handler));
+  }
+
+private:
+  // Disallow copying and assignment.
+  handler_work(const handler_work&);
+  handler_work& operator=(const handler_work&);
+
+  typename associated_executor<Handler>::type executor_;
+};
+
+// This specialisation dispatches a handler through the old invocation hook.
+// The specialisation is not strictly required for correctness, as the
+// system_executor will dispatch through the hook anyway. However, by doing
+// this we avoid an extra copy of the handler.
+template <typename Handler>
+class handler_work<Handler, system_executor>
+{
+public:
+  explicit handler_work(Handler&) ASIO_NOEXCEPT {}
+  static void start(Handler&) ASIO_NOEXCEPT {}
+  ~handler_work() {}
+
+  template <typename Function>
+  void complete(Function& function, Handler& handler)
+  {
+    asio_handler_invoke_helpers::invoke(function, handler);
+  }
+
+private:
+  // Disallow copying and assignment.
+  handler_work(const handler_work&);
+  handler_work& operator=(const handler_work&);
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_HANDLER_WORK_HPP
diff --git a/extern/include/asio/detail/hash_map.hpp b/extern/include/asio/detail/hash_map.hpp
index e11b5422..e70970d6 100644
--- a/extern/include/asio/detail/hash_map.hpp
+++ b/extern/include/asio/detail/hash_map.hpp
@@ -2,7 +2,7 @@
 // detail/hash_map.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -243,15 +243,15 @@ class hash_map
   {
     if (num_buckets == num_buckets_)
       return;
-    num_buckets_ = num_buckets;
-    ASIO_ASSERT(num_buckets_ != 0);
+    ASIO_ASSERT(num_buckets != 0);
 
     iterator end_iter = values_.end();
 
     // Update number of buckets and initialise all buckets to empty.
-    bucket_type* tmp = new bucket_type[num_buckets_];
+    bucket_type* tmp = new bucket_type[num_buckets];
     delete[] buckets_;
     buckets_ = tmp;
+    num_buckets_ = num_buckets;
     for (std::size_t i = 0; i < num_buckets_; ++i)
       buckets_[i].first = buckets_[i].last = end_iter;
 
diff --git a/extern/include/asio/detail/impl/buffer_sequence_adapter.ipp b/extern/include/asio/detail/impl/buffer_sequence_adapter.ipp
index f32764f0..323c8adb 100644
--- a/extern/include/asio/detail/impl/buffer_sequence_adapter.ipp
+++ b/extern/include/asio/detail/impl/buffer_sequence_adapter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/buffer_sequence_adapter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -39,16 +39,16 @@ class winrt_buffer_impl :
 public:
   explicit winrt_buffer_impl(const asio::const_buffer& b)
   {
-    bytes_ = const_cast<byte*>(asio::buffer_cast<const byte*>(b));
-    length_ = asio::buffer_size(b);
-    capacity_ = asio::buffer_size(b);
+    bytes_ = const_cast<byte*>(static_cast<const byte*>(b.data()));
+    length_ = b.size();
+    capacity_ = b.size();
   }
 
   explicit winrt_buffer_impl(const asio::mutable_buffer& b)
   {
-    bytes_ = const_cast<byte*>(asio::buffer_cast<const byte*>(b));
+    bytes_ = static_cast<byte*>(b.data());
     length_ = 0;
-    capacity_ = asio::buffer_size(b);
+    capacity_ = b.size();
   }
 
   ~winrt_buffer_impl()
diff --git a/extern/include/asio/detail/impl/descriptor_ops.ipp b/extern/include/asio/detail/impl/descriptor_ops.ipp
index 805bf05e..1af643fb 100644
--- a/extern/include/asio/detail/impl/descriptor_ops.ipp
+++ b/extern/include/asio/detail/impl/descriptor_ops.ipp
@@ -2,7 +2,7 @@
 // detail/impl/descriptor_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -438,6 +438,29 @@ int poll_write(int d, state_type state, asio::error_code& ec)
   return result;
 }
 
+int poll_error(int d, state_type state, asio::error_code& ec)
+{
+  if (d == -1)
+  {
+    ec = asio::error::bad_descriptor;
+    return -1;
+  }
+
+  pollfd fds;
+  fds.fd = d;
+  fds.events = POLLPRI | POLLERR | POLLHUP;
+  fds.revents = 0;
+  int timeout = (state & user_set_non_blocking) ? 0 : -1;
+  errno = 0;
+  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
+  if (result == 0)
+    ec = (state & user_set_non_blocking)
+      ? asio::error::would_block : asio::error_code();
+  else if (result > 0)
+    ec = asio::error_code();
+  return result;
+}
+
 } // namespace descriptor_ops
 } // namespace detail
 } // namespace asio
diff --git a/extern/include/asio/detail/impl/dev_poll_reactor.hpp b/extern/include/asio/detail/impl/dev_poll_reactor.hpp
index 7c26e4c0..4cd8aafe 100644
--- a/extern/include/asio/detail/impl/dev_poll_reactor.hpp
+++ b/extern/include/asio/detail/impl/dev_poll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/dev_poll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -45,12 +45,12 @@ void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op, false);
+    scheduler_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
+  scheduler_.work_started();
   if (earliest)
     interrupter_.interrupt();
 }
@@ -64,10 +64,23 @@ std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   op_queue<operation> ops;
   std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
   return n;
 }
 
+template <typename Time_Traits>
+void dev_poll_reactor::move_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& target,
+    typename timer_queue<Time_Traits>::per_timer_data& source)
+{
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer(target, ops);
+  queue.move_timer(target, source);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 } // namespace detail
 } // namespace asio
 
diff --git a/extern/include/asio/detail/impl/dev_poll_reactor.ipp b/extern/include/asio/detail/impl/dev_poll_reactor.ipp
index 34393700..1ca376c1 100644
--- a/extern/include/asio/detail/impl/dev_poll_reactor.ipp
+++ b/extern/include/asio/detail/impl/dev_poll_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/dev_poll_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -29,9 +29,9 @@
 namespace asio {
 namespace detail {
 
-dev_poll_reactor::dev_poll_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<dev_poll_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
+dev_poll_reactor::dev_poll_reactor(asio::execution_context& ctx)
+  : asio::detail::execution_context_service_base<dev_poll_reactor>(ctx),
+    scheduler_(use_service<scheduler>(ctx)),
     mutex_(),
     dev_poll_fd_(do_dev_poll_create()),
     interrupter_(),
@@ -47,11 +47,11 @@ dev_poll_reactor::dev_poll_reactor(asio::io_service& io_service)
 
 dev_poll_reactor::~dev_poll_reactor()
 {
-  shutdown_service();
+  shutdown();
   ::close(dev_poll_fd_);
 }
 
-void dev_poll_reactor::shutdown_service()
+void dev_poll_reactor::shutdown()
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
@@ -64,12 +64,13 @@ void dev_poll_reactor::shutdown_service()
 
   timer_queues_.get_all_timers(ops);
 
-  io_service_.abandon_operations(ops);
+  scheduler_.abandon_operations(ops);
 } 
 
-void dev_poll_reactor::fork_service(asio::io_service::fork_event fork_ev)
+void dev_poll_reactor::notify_fork(
+    asio::execution_context::fork_event fork_ev)
 {
-  if (fork_ev == asio::io_service::fork_child)
+  if (fork_ev == asio::execution_context::fork_child)
   {
     detail::mutex::scoped_lock lock(mutex_);
 
@@ -112,7 +113,7 @@ void dev_poll_reactor::fork_service(asio::io_service::fork_event fork_ev)
 
 void dev_poll_reactor::init_task()
 {
-  io_service_.init_task();
+  scheduler_.init_task();
 }
 
 int dev_poll_reactor::register_descriptor(socket_type, per_descriptor_data&)
@@ -167,7 +168,7 @@ void dev_poll_reactor::start_op(int op_type, socket_type descriptor,
         if (op->perform())
         {
           lock.unlock();
-          io_service_.post_immediate_completion(op, is_continuation);
+          scheduler_.post_immediate_completion(op, is_continuation);
           return;
         }
       }
@@ -175,7 +176,7 @@ void dev_poll_reactor::start_op(int op_type, socket_type descriptor,
   }
 
   bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-  io_service_.work_started();
+  scheduler_.work_started();
   if (first)
   {
     ::pollfd& ev = add_pending_event_change(descriptor);
@@ -234,13 +235,18 @@ void dev_poll_reactor::deregister_internal_descriptor(
     op_queue_[i].cancel_operations(descriptor, ops, ec);
 }
 
-void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
+void dev_poll_reactor::cleanup_descriptor_data(
+    dev_poll_reactor::per_descriptor_data&)
+{
+}
+
+void dev_poll_reactor::run(long usec, op_queue<operation>& ops)
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
 
   // We can return immediately if there's no work to do and the reactor is
   // not supposed to block.
-  if (!block && op_queue_[read_op].empty() && op_queue_[write_op].empty()
+  if (usec == 0 && op_queue_[read_op].empty() && op_queue_[write_op].empty()
       && op_queue_[except_op].empty() && timer_queues_.all_empty())
     return;
 
@@ -266,7 +272,15 @@ void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
     pending_event_change_index_.clear();
   }
 
-  int timeout = block ? get_timeout() : 0;
+  // Calculate timeout.
+  int timeout;
+  if (usec == 0)
+    timeout = 0;
+  else
+  {
+    timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1);
+    timeout = get_timeout(timeout);
+  }
   lock.unlock();
 
   // Block on the /dev/poll descriptor.
@@ -380,11 +394,13 @@ void dev_poll_reactor::do_remove_timer_queue(timer_queue_base& queue)
   timer_queues_.erase(&queue);
 }
 
-int dev_poll_reactor::get_timeout()
+int dev_poll_reactor::get_timeout(int msec)
 {
   // By default we will wait no longer than 5 minutes. This will ensure that
   // any changes to the system clock are detected after no longer than this.
-  return timer_queues_.wait_duration_msec(5 * 60 * 1000);
+  const int max_msec = 5 * 60 * 1000;
+  return timer_queues_.wait_duration_msec(
+      (msec < 0 || max_msec < msec) ? max_msec : msec);
 }
 
 void dev_poll_reactor::cancel_ops_unlocked(socket_type descriptor,
@@ -395,7 +411,7 @@ void dev_poll_reactor::cancel_ops_unlocked(socket_type descriptor,
   for (int i = 0; i < max_ops; ++i)
     need_interrupt = op_queue_[i].cancel_operations(
         descriptor, ops, ec) || need_interrupt;
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
   if (need_interrupt)
     interrupter_.interrupt();
 }
diff --git a/extern/include/asio/detail/impl/epoll_reactor.hpp b/extern/include/asio/detail/impl/epoll_reactor.hpp
index 8d276d12..f990059d 100644
--- a/extern/include/asio/detail/impl/epoll_reactor.hpp
+++ b/extern/include/asio/detail/impl/epoll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/epoll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -43,12 +43,12 @@ void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op, false);
+    scheduler_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
+  scheduler_.work_started();
   if (earliest)
     update_timeout();
 }
@@ -62,10 +62,23 @@ std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   op_queue<operation> ops;
   std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
   return n;
 }
 
+template <typename Time_Traits>
+void epoll_reactor::move_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& target,
+    typename timer_queue<Time_Traits>::per_timer_data& source)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer(target, ops);
+  queue.move_timer(target, source);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 } // namespace detail
 } // namespace asio
 
diff --git a/extern/include/asio/detail/impl/epoll_reactor.ipp b/extern/include/asio/detail/impl/epoll_reactor.ipp
index 8af8dfef..65584a43 100644
--- a/extern/include/asio/detail/impl/epoll_reactor.ipp
+++ b/extern/include/asio/detail/impl/epoll_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/epoll_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -34,14 +34,16 @@
 namespace asio {
 namespace detail {
 
-epoll_reactor::epoll_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<epoll_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
-    mutex_(),
+epoll_reactor::epoll_reactor(asio::execution_context& ctx)
+  : execution_context_service_base<epoll_reactor>(ctx),
+    scheduler_(use_service<scheduler>(ctx)),
+    mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          REACTOR_REGISTRATION, scheduler_.concurrency_hint())),
     interrupter_(),
     epoll_fd_(do_epoll_create()),
     timer_fd_(do_timerfd_create()),
-    shutdown_(false)
+    shutdown_(false),
+    registered_descriptors_mutex_(mutex_.enabled())
 {
   // Add the interrupter's descriptor to epoll.
   epoll_event ev = { 0, { 0 } };
@@ -67,7 +69,7 @@ epoll_reactor::~epoll_reactor()
     close(timer_fd_);
 }
 
-void epoll_reactor::shutdown_service()
+void epoll_reactor::shutdown()
 {
   mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
@@ -85,12 +87,13 @@ void epoll_reactor::shutdown_service()
 
   timer_queues_.get_all_timers(ops);
 
-  io_service_.abandon_operations(ops);
+  scheduler_.abandon_operations(ops);
 }
 
-void epoll_reactor::fork_service(asio::io_service::fork_event fork_ev)
+void epoll_reactor::notify_fork(
+    asio::execution_context::fork_event fork_ev)
 {
-  if (fork_ev == asio::io_service::fork_child)
+  if (fork_ev == asio::execution_context::fork_child)
   {
     if (epoll_fd_ != -1)
       ::close(epoll_fd_);
@@ -141,7 +144,7 @@ void epoll_reactor::fork_service(asio::io_service::fork_event fork_ev)
 
 void epoll_reactor::init_task()
 {
-  io_service_.init_task();
+  scheduler_.init_task();
 }
 
 int epoll_reactor::register_descriptor(socket_type descriptor,
@@ -149,12 +152,18 @@ int epoll_reactor::register_descriptor(socket_type descriptor,
 {
   descriptor_data = allocate_descriptor_state();
 
+  ASIO_HANDLER_REACTOR_REGISTRATION((
+        context(), static_cast<uintmax_t>(descriptor),
+        reinterpret_cast<uintmax_t>(descriptor_data)));
+
   {
     mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
     descriptor_data->reactor_ = this;
     descriptor_data->descriptor_ = descriptor;
     descriptor_data->shutdown_ = false;
+    for (int i = 0; i < max_ops; ++i)
+      descriptor_data->try_speculative_[i] = true;
   }
 
   epoll_event ev = { 0, { 0 } };
@@ -163,7 +172,18 @@ int epoll_reactor::register_descriptor(socket_type descriptor,
   ev.data.ptr = descriptor_data;
   int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
   if (result != 0)
+  {
+    if (errno == EPERM)
+    {
+      // This file descriptor type is not supported by epoll. However, if it is
+      // a regular file then operations on it will not block. We will allow
+      // this descriptor to be used and fail later if an operation on it would
+      // otherwise require a trip through the reactor.
+      descriptor_data->registered_events_ = 0;
+      return 0;
+    }
     return errno;
+  }
 
   return 0;
 }
@@ -174,6 +194,10 @@ int epoll_reactor::register_internal_descriptor(
 {
   descriptor_data = allocate_descriptor_state();
 
+  ASIO_HANDLER_REACTOR_REGISTRATION((
+        context(), static_cast<uintmax_t>(descriptor),
+        reinterpret_cast<uintmax_t>(descriptor_data)));
+
   {
     mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
@@ -181,6 +205,8 @@ int epoll_reactor::register_internal_descriptor(
     descriptor_data->descriptor_ = descriptor;
     descriptor_data->shutdown_ = false;
     descriptor_data->op_queue_[op_type].push(op);
+    for (int i = 0; i < max_ops; ++i)
+      descriptor_data->try_speculative_[i] = true;
   }
 
   epoll_event ev = { 0, { 0 } };
@@ -227,10 +253,23 @@ void epoll_reactor::start_op(int op_type, socket_type descriptor,
         && (op_type != read_op
           || descriptor_data->op_queue_[except_op].empty()))
     {
-      if (op->perform())
+      if (descriptor_data->try_speculative_[op_type])
       {
-        descriptor_lock.unlock();
-        io_service_.post_immediate_completion(op, is_continuation);
+        if (reactor_op::status status = op->perform())
+        {
+          if (status == reactor_op::done_and_exhausted)
+            if (descriptor_data->registered_events_ != 0)
+              descriptor_data->try_speculative_[op_type] = false;
+          descriptor_lock.unlock();
+          scheduler_.post_immediate_completion(op, is_continuation);
+          return;
+        }
+      }
+
+      if (descriptor_data->registered_events_ == 0)
+      {
+        op->ec_ = asio::error::operation_not_supported;
+        scheduler_.post_immediate_completion(op, is_continuation);
         return;
       }
 
@@ -249,12 +288,18 @@ void epoll_reactor::start_op(int op_type, socket_type descriptor,
           {
             op->ec_ = asio::error_code(errno,
                 asio::error::get_system_category());
-            io_service_.post_immediate_completion(op, is_continuation);
+            scheduler_.post_immediate_completion(op, is_continuation);
             return;
           }
         }
       }
     }
+    else if (descriptor_data->registered_events_ == 0)
+    {
+      op->ec_ = asio::error::operation_not_supported;
+      scheduler_.post_immediate_completion(op, is_continuation);
+      return;
+    }
     else
     {
       if (op_type == write_op)
@@ -270,7 +315,7 @@ void epoll_reactor::start_op(int op_type, socket_type descriptor,
   }
 
   descriptor_data->op_queue_[op_type].push(op);
-  io_service_.work_started();
+  scheduler_.work_started();
 }
 
 void epoll_reactor::cancel_ops(socket_type,
@@ -294,7 +339,7 @@ void epoll_reactor::cancel_ops(socket_type,
 
   descriptor_lock.unlock();
 
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
 }
 
 void epoll_reactor::deregister_descriptor(socket_type descriptor,
@@ -312,7 +357,7 @@ void epoll_reactor::deregister_descriptor(socket_type descriptor,
       // The descriptor will be automatically removed from the epoll set when
       // it is closed.
     }
-    else
+    else if (descriptor_data->registered_events_ != 0)
     {
       epoll_event ev = { 0, { 0 } };
       epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
@@ -334,10 +379,20 @@ void epoll_reactor::deregister_descriptor(socket_type descriptor,
 
     descriptor_lock.unlock();
 
-    free_descriptor_state(descriptor_data);
-    descriptor_data = 0;
+    ASIO_HANDLER_REACTOR_DEREGISTRATION((
+          context(), static_cast<uintmax_t>(descriptor),
+          reinterpret_cast<uintmax_t>(descriptor_data)));
 
-    io_service_.post_deferred_completions(ops);
+    scheduler_.post_deferred_completions(ops);
+
+    // Leave descriptor_data set so that it will be freed by the subsequent
+    // call to cleanup_descriptor_data.
+  }
+  else
+  {
+    // We are shutting down, so prevent cleanup_descriptor_data from freeing
+    // the descriptor_data object and let the destructor free it instead.
+    descriptor_data = 0;
   }
 }
 
@@ -363,33 +418,87 @@ void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
 
     descriptor_lock.unlock();
 
+    ASIO_HANDLER_REACTOR_DEREGISTRATION((
+          context(), static_cast<uintmax_t>(descriptor),
+          reinterpret_cast<uintmax_t>(descriptor_data)));
+
+    // Leave descriptor_data set so that it will be freed by the subsequent
+    // call to cleanup_descriptor_data.
+  }
+  else
+  {
+    // We are shutting down, so prevent cleanup_descriptor_data from freeing
+    // the descriptor_data object and let the destructor free it instead.
+    descriptor_data = 0;
+  }
+}
+
+void epoll_reactor::cleanup_descriptor_data(
+    per_descriptor_data& descriptor_data)
+{
+  if (descriptor_data)
+  {
     free_descriptor_state(descriptor_data);
     descriptor_data = 0;
   }
 }
 
-void epoll_reactor::run(bool block, op_queue<operation>& ops)
+void epoll_reactor::run(long usec, op_queue<operation>& ops)
 {
-  // This code relies on the fact that the task_io_service queues the reactor
-  // task behind all descriptor operations generated by this function. This
-  // means, that by the time we reach this point, any previously returned
-  // descriptor operations have already been dequeued. Therefore it is now safe
-  // for us to reuse and return them for the task_io_service to queue again.
+  // This code relies on the fact that the scheduler queues the reactor task
+  // behind all descriptor operations generated by this function. This means,
+  // that by the time we reach this point, any previously returned descriptor
+  // operations have already been dequeued. Therefore it is now safe for us to
+  // reuse and return them for the scheduler to queue again.
 
-  // Calculate a timeout only if timerfd is not used.
+  // Calculate timeout. Check the timer queues only if timerfd is not in use.
   int timeout;
-  if (timer_fd_ != -1)
-    timeout = block ? -1 : 0;
+  if (usec == 0)
+    timeout = 0;
   else
   {
-    mutex::scoped_lock lock(mutex_);
-    timeout = block ? get_timeout() : 0;
+    timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1);
+    if (timer_fd_ == -1)
+    {
+      mutex::scoped_lock lock(mutex_);
+      timeout = get_timeout(timeout);
+    }
   }
 
   // Block on the epoll descriptor.
   epoll_event events[128];
   int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
 
+#if defined(ASIO_ENABLE_HANDLER_TRACKING)
+  // Trace the waiting events.
+  for (int i = 0; i < num_events; ++i)
+  {
+    void* ptr = events[i].data.ptr;
+    if (ptr == &interrupter_)
+    {
+      // Ignore.
+    }
+# if defined(ASIO_HAS_TIMERFD)
+    else if (ptr == &timer_fd_)
+    {
+      // Ignore.
+    }
+# endif // defined(ASIO_HAS_TIMERFD)
+    else
+    {
+      unsigned event_mask = 0;
+      if ((events[i].events & EPOLLIN) != 0)
+        event_mask |= ASIO_HANDLER_REACTOR_READ_EVENT;
+      if ((events[i].events & EPOLLOUT))
+        event_mask |= ASIO_HANDLER_REACTOR_WRITE_EVENT;
+      if ((events[i].events & (EPOLLERR | EPOLLHUP)) != 0)
+        event_mask |= ASIO_HANDLER_REACTOR_ERROR_EVENT;
+      ASIO_HANDLER_REACTOR_EVENTS((context(),
+            reinterpret_cast<uintmax_t>(ptr), event_mask));
+    }
+  }
+#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
+
 #if defined(ASIO_HAS_TIMERFD)
   bool check_timers = (timer_fd_ == -1);
 #else // defined(ASIO_HAS_TIMERFD)
@@ -423,11 +532,18 @@ void epoll_reactor::run(bool block, op_queue<operation>& ops)
     else
     {
       // The descriptor operation doesn't count as work in and of itself, so we
-      // don't call work_started() here. This still allows the io_service to
+      // don't call work_started() here. This still allows the scheduler to
       // stop if the only remaining operations are descriptor operations.
       descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
-      descriptor_data->set_ready_events(events[i].events);
-      ops.push(descriptor_data);
+      if (!ops.is_enqueued(descriptor_data))
+      {
+        descriptor_data->set_ready_events(events[i].events);
+        ops.push(descriptor_data);
+      }
+      else
+      {
+        descriptor_data->add_ready_events(events[i].events);
+      }
     }
   }
 
@@ -508,7 +624,8 @@ int epoll_reactor::do_timerfd_create()
 epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
 {
   mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  return registered_descriptors_.alloc();
+  return registered_descriptors_.alloc(ASIO_CONCURRENCY_HINT_IS_LOCKING(
+        REACTOR_IO, scheduler_.concurrency_hint()));
 }
 
 void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
@@ -544,11 +661,13 @@ void epoll_reactor::update_timeout()
   interrupt();
 }
 
-int epoll_reactor::get_timeout()
+int epoll_reactor::get_timeout(int msec)
 {
   // By default we will wait no longer than 5 minutes. This will ensure that
   // any changes to the system clock are detected after no longer than this.
-  return timer_queues_.wait_duration_msec(5 * 60 * 1000);
+  const int max_msec = 5 * 60 * 1000;
+  return timer_queues_.wait_duration_msec(
+      (msec < 0 || max_msec < msec) ? max_msec : msec);
 }
 
 #if defined(ASIO_HAS_TIMERFD)
@@ -578,19 +697,18 @@ struct epoll_reactor::perform_io_cleanup_on_block_exit
     {
       // Post the remaining completed operations for invocation.
       if (!ops_.empty())
-        reactor_->io_service_.post_deferred_completions(ops_);
+        reactor_->scheduler_.post_deferred_completions(ops_);
 
       // A user-initiated operation has completed, but there's no need to
       // explicitly call work_finished() here. Instead, we'll take advantage of
-      // the fact that the task_io_service will call work_finished() once we
-      // return.
+      // the fact that the scheduler will call work_finished() once we return.
     }
     else
     {
       // No user-initiated operations have completed, so we need to compensate
-      // for the work_finished() call that the task_io_service will make once
-      // this operation returns.
-      reactor_->io_service_.work_started();
+      // for the work_finished() call that the scheduler will make once this
+      // operation returns.
+      reactor_->scheduler_.compensating_work_started();
     }
   }
 
@@ -599,8 +717,9 @@ struct epoll_reactor::perform_io_cleanup_on_block_exit
   operation* first_op_;
 };
 
-epoll_reactor::descriptor_state::descriptor_state()
-  : operation(&epoll_reactor::descriptor_state::do_complete)
+epoll_reactor::descriptor_state::descriptor_state(bool locking)
+  : operation(&epoll_reactor::descriptor_state::do_complete),
+    mutex_(locking)
 {
 }
 
@@ -617,12 +736,18 @@ operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
   {
     if (events & (flag[j] | EPOLLERR | EPOLLHUP))
     {
+      try_speculative_[j] = true;
       while (reactor_op* op = op_queue_[j].front())
       {
-        if (op->perform())
+        if (reactor_op::status status = op->perform())
         {
           op_queue_[j].pop();
           io_cleanup.ops_.push(op);
+          if (status == reactor_op::done_and_exhausted)
+          {
+            try_speculative_[j] = false;
+            break;
+          }
         }
         else
           break;
@@ -638,7 +763,7 @@ operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
 }
 
 void epoll_reactor::descriptor_state::do_complete(
-    io_service_impl* owner, operation* base,
+    void* owner, operation* base,
     const asio::error_code& ec, std::size_t bytes_transferred)
 {
   if (owner)
@@ -647,7 +772,7 @@ void epoll_reactor::descriptor_state::do_complete(
     uint32_t events = static_cast<uint32_t>(bytes_transferred);
     if (operation* op = descriptor_data->perform_io(events))
     {
-      op->complete(*owner, ec, 0);
+      op->complete(owner, ec, 0);
     }
   }
 }
diff --git a/extern/include/asio/detail/impl/eventfd_select_interrupter.ipp b/extern/include/asio/detail/impl/eventfd_select_interrupter.ipp
index 744ab0c4..c56e89ad 100644
--- a/extern/include/asio/detail/impl/eventfd_select_interrupter.ipp
+++ b/extern/include/asio/detail/impl/eventfd_select_interrupter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/eventfd_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/extern/include/asio/detail/impl/handler_tracking.ipp b/extern/include/asio/detail/impl/handler_tracking.ipp
index 29fbe515..5a4ff6f0 100644
--- a/extern/include/asio/detail/impl/handler_tracking.ipp
+++ b/extern/include/asio/detail/impl/handler_tracking.ipp
@@ -2,7 +2,7 @@
 // detail/impl/handler_tracking.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,7 +17,11 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
+#if defined(ASIO_CUSTOM_HANDLER_TRACKING)
+
+// The handler tracking implementation is provided by the user-specified header.
+
+#elif defined(ASIO_ENABLE_HANDLER_TRACKING)
 
 #include <cstdarg>
 #include <cstdio>
@@ -25,17 +29,15 @@
 
 #if defined(ASIO_HAS_BOOST_DATE_TIME)
 # include "asio/time_traits.hpp"
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-# if defined(ASIO_HAS_STD_CHRONO)
-#  include <chrono>
-# elif defined(ASIO_HAS_BOOST_CHRONO)
-#  include <boost/chrono/system_clocks.hpp>
-# endif
+#elif defined(ASIO_HAS_CHRONO)
+# include "asio/detail/chrono.hpp"
 # include "asio/detail/chrono_time_traits.hpp"
 # include "asio/wait_traits.hpp"
 #endif // defined(ASIO_HAS_BOOST_DATE_TIME)
 
-#if !defined(ASIO_WINDOWS)
+#if defined(ASIO_WINDOWS_RUNTIME)
+# include "asio/detail/socket_types.hpp"
+#elif !defined(ASIO_WINDOWS)
 # include <unistd.h>
 #endif // !defined(ASIO_WINDOWS)
 
@@ -55,16 +57,11 @@ struct handler_tracking_timestamp
     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;
-#elif defined(ASIO_HAS_STD_CHRONO)
-    typedef chrono_time_traits<std::chrono::system_clock,
-        asio::wait_traits<std::chrono::system_clock> > traits_helper;
-    traits_helper::posix_time_duration now(
-        std::chrono::system_clock::now().time_since_epoch());
-#elif defined(ASIO_HAS_BOOST_CHRONO)
-    typedef chrono_time_traits<boost::chrono::system_clock,
-        asio::wait_traits<boost::chrono::system_clock> > traits_helper;
+#elif defined(ASIO_HAS_CHRONO)
+    typedef chrono_time_traits<chrono::system_clock,
+        asio::wait_traits<chrono::system_clock> > traits_helper;
     traits_helper::posix_time_duration now(
-        boost::chrono::system_clock::now().time_since_epoch());
+        chrono::system_clock::now().time_since_epoch());
 #endif
     seconds = static_cast<uint64_t>(now.total_seconds());
     microseconds = static_cast<uint64_t>(now.total_microseconds() % 1000000);
@@ -95,13 +92,15 @@ void handler_tracking::init()
     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)
+void handler_tracking::creation(execution_context&,
+    handler_tracking::tracked_handler& h,
+    const char* object_type, void* object,
+    uintmax_t /*native_handle*/, const char* op_name)
 {
   static tracking_state* state = get_state();
 
   static_mutex::scoped_lock lock(state->mutex_);
-  h->id_ = state->next_id_++;
+  h.id_ = state->next_id_++;
   lock.unlock();
 
   handler_tracking_timestamp timestamp;
@@ -117,11 +116,12 @@ void handler_tracking::creation(handler_tracking::tracked_handler* h,
       "@asio|%llu.%06llu|%llu*%llu|%.20s@%p.%.50s\n",
 #endif // defined(ASIO_WINDOWS)
       timestamp.seconds, timestamp.microseconds,
-      current_id, h->id_, object_type, object, op_name);
+      current_id, h.id_, object_type, object, op_name);
 }
 
-handler_tracking::completion::completion(handler_tracking::tracked_handler* h)
-  : id_(h->id_),
+handler_tracking::completion::completion(
+    const handler_tracking::tracked_handler& h)
+  : id_(h.id_),
     invoked_(false),
     next_(*get_state()->current_completion_)
 {
@@ -249,8 +249,9 @@ void handler_tracking::completion::invocation_end()
   }
 }
 
-void handler_tracking::operation(const char* object_type,
-    void* object, const char* op_name)
+void handler_tracking::operation(execution_context&,
+    const char* object_type, void* object,
+    uintmax_t /*native_handle*/, const char* op_name)
 {
   static tracking_state* state = get_state();
 
@@ -270,6 +271,54 @@ void handler_tracking::operation(const char* object_type,
       current_id, object_type, object, op_name);
 }
 
+void handler_tracking::reactor_registration(execution_context& /*context*/,
+    uintmax_t /*native_handle*/, uintmax_t /*registration*/)
+{
+}
+
+void handler_tracking::reactor_deregistration(execution_context& /*context*/,
+    uintmax_t /*native_handle*/, uintmax_t /*registration*/)
+{
+}
+
+void handler_tracking::reactor_events(execution_context& /*context*/,
+    uintmax_t /*native_handle*/, unsigned /*events*/)
+{
+}
+
+void handler_tracking::reactor_operation(
+    const tracked_handler& h, const char* op_name,
+    const asio::error_code& ec)
+{
+  handler_tracking_timestamp timestamp;
+
+  write_line(
+#if defined(ASIO_WINDOWS)
+      "@asio|%I64u.%06I64u|.%I64u|%s,ec=%.20s:%d\n",
+#else // defined(ASIO_WINDOWS)
+      "@asio|%llu.%06llu|.%llu|%s,ec=%.20s:%d\n",
+#endif // defined(ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
+      h.id_, op_name, ec.category().name(), ec.value());
+}
+
+void handler_tracking::reactor_operation(
+    const tracked_handler& h, const char* op_name,
+    const asio::error_code& ec, std::size_t bytes_transferred)
+{
+  handler_tracking_timestamp timestamp;
+
+  write_line(
+#if defined(ASIO_WINDOWS)
+      "@asio|%I64u.%06I64u|.%I64u|%s,ec=%.20s:%d,bytes_transferred=%I64u\n",
+#else // defined(ASIO_WINDOWS)
+      "@asio|%llu.%06llu|.%llu|%s,ec=%.20s:%d,bytes_transferred=%llu\n",
+#endif // defined(ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
+      h.id_, op_name, ec.category().name(), ec.value(),
+      static_cast<uint64_t>(bytes_transferred));
+}
+
 void handler_tracking::write_line(const char* format, ...)
 {
   using namespace std; // For sprintf (or equivalent).
@@ -286,7 +335,11 @@ void handler_tracking::write_line(const char* format, ...)
 
   va_end(args);
 
-#if defined(ASIO_WINDOWS)
+#if defined(ASIO_WINDOWS_RUNTIME)
+  wchar_t wline[256] = L"";
+  mbstowcs_s(0, wline, sizeof(wline) / sizeof(wchar_t), line, length);
+  ::OutputDebugStringW(wline);
+#elif defined(ASIO_WINDOWS)
   HANDLE stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE);
   DWORD bytes_written = 0;
   ::WriteFile(stderr_handle, line, length, &bytes_written, 0);
diff --git a/extern/include/asio/detail/impl/kqueue_reactor.hpp b/extern/include/asio/detail/impl/kqueue_reactor.hpp
index 42cff032..136d1678 100644
--- a/extern/include/asio/detail/impl/kqueue_reactor.hpp
+++ b/extern/include/asio/detail/impl/kqueue_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/kqueue_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -43,16 +43,16 @@ void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
     const typename Time_Traits::time_type& time,
     typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
 {
-  asio::detail::mutex::scoped_lock lock(mutex_);
+  mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op, false);
+    scheduler_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
+  scheduler_.work_started();
   if (earliest)
     interrupt();
 }
@@ -62,14 +62,27 @@ std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& timer,
     std::size_t max_cancelled)
 {
-  asio::detail::mutex::scoped_lock lock(mutex_);
+  mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
   std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
   return n;
 }
 
+template <typename Time_Traits>
+void kqueue_reactor::move_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& target,
+    typename timer_queue<Time_Traits>::per_timer_data& source)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer(target, ops);
+  queue.move_timer(target, source);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 } // namespace detail
 } // namespace asio
 
diff --git a/extern/include/asio/detail/impl/kqueue_reactor.ipp b/extern/include/asio/detail/impl/kqueue_reactor.ipp
index 264364fc..73986e0e 100644
--- a/extern/include/asio/detail/impl/kqueue_reactor.ipp
+++ b/extern/include/asio/detail/impl/kqueue_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/kqueue_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -21,6 +21,7 @@
 #if defined(ASIO_HAS_KQUEUE)
 
 #include "asio/detail/kqueue_reactor.hpp"
+#include "asio/detail/scheduler.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
 
@@ -38,13 +39,15 @@
 namespace asio {
 namespace detail {
 
-kqueue_reactor::kqueue_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<kqueue_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
-    mutex_(),
+kqueue_reactor::kqueue_reactor(asio::execution_context& ctx)
+  : execution_context_service_base<kqueue_reactor>(ctx),
+    scheduler_(use_service<scheduler>(ctx)),
+    mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          REACTOR_REGISTRATION, scheduler_.concurrency_hint())),
     kqueue_fd_(do_kqueue_create()),
     interrupter_(),
-    shutdown_(false)
+    shutdown_(false),
+    registered_descriptors_mutex_(mutex_.enabled())
 {
   struct kevent events[1];
   ASIO_KQUEUE_EV_SET(&events[0], interrupter_.read_descriptor(),
@@ -62,7 +65,7 @@ kqueue_reactor::~kqueue_reactor()
   close(kqueue_fd_);
 }
 
-void kqueue_reactor::shutdown_service()
+void kqueue_reactor::shutdown()
 {
   mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
@@ -80,12 +83,13 @@ void kqueue_reactor::shutdown_service()
 
   timer_queues_.get_all_timers(ops);
 
-  io_service_.abandon_operations(ops);
+  scheduler_.abandon_operations(ops);
 }
 
-void kqueue_reactor::fork_service(asio::io_service::fork_event fork_ev)
+void kqueue_reactor::notify_fork(
+    asio::execution_context::fork_event fork_ev)
 {
-  if (fork_ev == asio::io_service::fork_child)
+  if (fork_ev == asio::execution_context::fork_child)
   {
     // The kqueue descriptor is automatically closed in the child.
     kqueue_fd_ = -1;
@@ -127,7 +131,7 @@ void kqueue_reactor::fork_service(asio::io_service::fork_event fork_ev)
 
 void kqueue_reactor::init_task()
 {
-  io_service_.init_task();
+  scheduler_.init_task();
 }
 
 int kqueue_reactor::register_descriptor(socket_type descriptor,
@@ -135,6 +139,10 @@ int kqueue_reactor::register_descriptor(socket_type descriptor,
 {
   descriptor_data = allocate_descriptor_state();
 
+  ASIO_HANDLER_REACTOR_REGISTRATION((
+        context(), static_cast<uintmax_t>(descriptor),
+        reinterpret_cast<uintmax_t>(descriptor_data)));
+
   mutex::scoped_lock lock(descriptor_data->mutex_);
 
   descriptor_data->descriptor_ = descriptor;
@@ -150,6 +158,10 @@ int kqueue_reactor::register_internal_descriptor(
 {
   descriptor_data = allocate_descriptor_state();
 
+  ASIO_HANDLER_REACTOR_REGISTRATION((
+        context(), static_cast<uintmax_t>(descriptor),
+        reinterpret_cast<uintmax_t>(descriptor_data)));
+
   mutex::scoped_lock lock(descriptor_data->mutex_);
 
   descriptor_data->descriptor_ = descriptor;
@@ -204,7 +216,7 @@ void kqueue_reactor::start_op(int op_type, socket_type descriptor,
       if (op->perform())
       {
         descriptor_lock.unlock();
-        io_service_.post_immediate_completion(op, is_continuation);
+        scheduler_.post_immediate_completion(op, is_continuation);
         return;
       }
 
@@ -223,7 +235,7 @@ void kqueue_reactor::start_op(int op_type, socket_type descriptor,
         {
           op->ec_ = asio::error_code(errno,
               asio::error::get_system_category());
-          io_service_.post_immediate_completion(op, is_continuation);
+          scheduler_.post_immediate_completion(op, is_continuation);
           return;
         }
       }
@@ -243,7 +255,7 @@ void kqueue_reactor::start_op(int op_type, socket_type descriptor,
   }
 
   descriptor_data->op_queue_[op_type].push(op);
-  io_service_.work_started();
+  scheduler_.work_started();
 }
 
 void kqueue_reactor::cancel_ops(socket_type,
@@ -267,7 +279,7 @@ void kqueue_reactor::cancel_ops(socket_type,
 
   descriptor_lock.unlock();
 
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
 }
 
 void kqueue_reactor::deregister_descriptor(socket_type descriptor,
@@ -311,10 +323,20 @@ void kqueue_reactor::deregister_descriptor(socket_type descriptor,
 
     descriptor_lock.unlock();
 
-    free_descriptor_state(descriptor_data);
-    descriptor_data = 0;
+    ASIO_HANDLER_REACTOR_DEREGISTRATION((
+          context(), static_cast<uintmax_t>(descriptor),
+          reinterpret_cast<uintmax_t>(descriptor_data)));
 
-    io_service_.post_deferred_completions(ops);
+    scheduler_.post_deferred_completions(ops);
+
+    // Leave descriptor_data set so that it will be freed by the subsequent
+    // call to cleanup_descriptor_data.
+  }
+  else
+  {
+    // We are shutting down, so prevent cleanup_descriptor_data from freeing
+    // the descriptor_data object and let the destructor free it instead.
+    descriptor_data = 0;
   }
 }
 
@@ -344,18 +366,38 @@ void kqueue_reactor::deregister_internal_descriptor(socket_type descriptor,
 
     descriptor_lock.unlock();
 
+    ASIO_HANDLER_REACTOR_DEREGISTRATION((
+          context(), static_cast<uintmax_t>(descriptor),
+          reinterpret_cast<uintmax_t>(descriptor_data)));
+
+    // Leave descriptor_data set so that it will be freed by the subsequent
+    // call to cleanup_descriptor_data.
+  }
+  else
+  {
+    // We are shutting down, so prevent cleanup_descriptor_data from freeing
+    // the descriptor_data object and let the destructor free it instead.
+    descriptor_data = 0;
+  }
+}
+
+void kqueue_reactor::cleanup_descriptor_data(
+    per_descriptor_data& descriptor_data)
+{
+  if (descriptor_data)
+  {
     free_descriptor_state(descriptor_data);
     descriptor_data = 0;
   }
 }
 
-void kqueue_reactor::run(bool block, op_queue<operation>& ops)
+void kqueue_reactor::run(long usec, op_queue<operation>& ops)
 {
   mutex::scoped_lock lock(mutex_);
 
   // Determine how long to block while waiting for events.
   timespec timeout_buf = { 0, 0 };
-  timespec* timeout = block ? get_timeout(timeout_buf) : &timeout_buf;
+  timespec* timeout = usec ? get_timeout(usec, timeout_buf) : &timeout_buf;
 
   lock.unlock();
 
@@ -363,6 +405,31 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
   struct kevent events[128];
   int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout);
 
+#if defined(ASIO_ENABLE_HANDLER_TRACKING)
+  // Trace the waiting events.
+  for (int i = 0; i < num_events; ++i)
+  {
+    void* ptr = reinterpret_cast<void*>(events[i].udata);
+    if (ptr != &interrupter_)
+    {
+      unsigned event_mask = 0;
+      switch (events[i].filter)
+      {
+      case EVFILT_READ:
+        event_mask |= ASIO_HANDLER_REACTOR_READ_EVENT;
+        break;
+      case EVFILT_WRITE:
+        event_mask |= ASIO_HANDLER_REACTOR_WRITE_EVENT;
+        break;
+      }
+      if ((events[i].flags & (EV_ERROR | EV_OOBAND)) != 0)
+        event_mask |= ASIO_HANDLER_REACTOR_ERROR_EVENT;
+      ASIO_HANDLER_REACTOR_EVENTS((context(),
+            reinterpret_cast<uintmax_t>(ptr), event_mask));
+    }
+  }
+#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
+
   // Dispatch the waiting events.
   for (int i = 0; i < num_events; ++i)
   {
@@ -453,7 +520,8 @@ int kqueue_reactor::do_kqueue_create()
 kqueue_reactor::descriptor_state* kqueue_reactor::allocate_descriptor_state()
 {
   mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  return registered_descriptors_.alloc();
+  return registered_descriptors_.alloc(ASIO_CONCURRENCY_HINT_IS_LOCKING(
+        REACTOR_IO, scheduler_.concurrency_hint()));
 }
 
 void kqueue_reactor::free_descriptor_state(kqueue_reactor::descriptor_state* s)
@@ -474,11 +542,13 @@ void kqueue_reactor::do_remove_timer_queue(timer_queue_base& queue)
   timer_queues_.erase(&queue);
 }
 
-timespec* kqueue_reactor::get_timeout(timespec& ts)
+timespec* kqueue_reactor::get_timeout(long usec, timespec& ts)
 {
   // By default we will wait no longer than 5 minutes. This will ensure that
   // any changes to the system clock are detected after no longer than this.
-  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
+  const long max_usec = 5 * 60 * 1000 * 1000;
+  usec = timer_queues_.wait_duration_usec(
+      (usec < 0 || max_usec < usec) ? max_usec : usec);
   ts.tv_sec = usec / 1000000;
   ts.tv_nsec = (usec % 1000000) * 1000;
   return &ts;
diff --git a/extern/include/asio/detail/impl/null_event.ipp b/extern/include/asio/detail/impl/null_event.ipp
new file mode 100644
index 00000000..22ade40b
--- /dev/null
+++ b/extern/include/asio/detail/impl/null_event.ipp
@@ -0,0 +1,74 @@
+//
+// detail/impl/null_event.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_NULL_EVENT_IPP
+#define ASIO_DETAIL_IMPL_NULL_EVENT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS_RUNTIME)
+# include <thread>
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+# include "asio/detail/socket_types.hpp"
+#else
+# include <unistd.h>
+# if defined(__hpux)
+#  include <sys/time.h>
+# endif
+# if !defined(__hpux) || defined(__SELECT)
+#  include <sys/select.h>
+# endif
+#endif
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+void null_event::do_wait()
+{
+#if defined(ASIO_WINDOWS_RUNTIME)
+  std::this_thread::sleep_until((std::chrono::steady_clock::time_point::max)());
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  ::Sleep(INFINITE);
+#else
+  ::pause();
+#endif
+}
+
+void null_event::do_wait_for_usec(long usec)
+{
+#if defined(ASIO_WINDOWS_RUNTIME)
+  std::this_thread::sleep_for(std::chrono::microseconds(usec));
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  ::Sleep(usec / 1000);
+#elif defined(__hpux) && defined(__SELECT)
+  timespec ts;
+  ts.tv_sec = usec / 1000000;
+  ts.tv_nsec = (usec % 1000000) * 1000;
+  ::pselect(0, 0, 0, 0, &ts, 0);
+#else
+  timeval tv;
+  tv.tv_sec = usec / 1000000;
+  tv.tv_usec = usec % 1000000;
+  ::select(0, 0, 0, 0, &tv);
+#endif
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_IMPL_NULL_EVENT_IPP
diff --git a/extern/include/asio/detail/impl/pipe_select_interrupter.ipp b/extern/include/asio/detail/impl/pipe_select_interrupter.ipp
index d05f16f5..13931ab8 100644
--- a/extern/include/asio/detail/impl/pipe_select_interrupter.ipp
+++ b/extern/include/asio/detail/impl/pipe_select_interrupter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/pipe_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/impl/posix_event.ipp b/extern/include/asio/detail/impl/posix_event.ipp
index ec2c1164..4b46ab08 100644
--- a/extern/include/asio/detail/impl/posix_event.ipp
+++ b/extern/include/asio/detail/impl/posix_event.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_event.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,7 +31,19 @@ namespace detail {
 posix_event::posix_event()
   : state_(0)
 {
+#if (defined(__MACH__) && defined(__APPLE__)) \
+      || (defined(__ANDROID__) && (__ANDROID_API__ < 21))
   int error = ::pthread_cond_init(&cond_, 0);
+#else // (defined(__MACH__) && defined(__APPLE__))
+      // || (defined(__ANDROID__) && (__ANDROID_API__ < 21))
+  ::pthread_condattr_t attr;
+  ::pthread_condattr_init(&attr);
+  int error = ::pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
+  if (error == 0)
+    error = ::pthread_cond_init(&cond_, &attr);
+#endif // (defined(__MACH__) && defined(__APPLE__))
+       // || (defined(__ANDROID__) && (__ANDROID_API__ < 21))
+
   asio::error_code ec(error,
       asio::error::get_system_category());
   asio::detail::throw_error(ec, "event");
diff --git a/extern/include/asio/detail/impl/posix_mutex.ipp b/extern/include/asio/detail/impl/posix_mutex.ipp
index a7688672..27272b57 100644
--- a/extern/include/asio/detail/impl/posix_mutex.ipp
+++ b/extern/include/asio/detail/impl/posix_mutex.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/impl/posix_thread.ipp b/extern/include/asio/detail/impl/posix_thread.ipp
index a6a93202..69bd16f9 100644
--- a/extern/include/asio/detail/impl/posix_thread.ipp
+++ b/extern/include/asio/detail/impl/posix_thread.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_thread.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -43,6 +43,16 @@ void posix_thread::join()
   }
 }
 
+std::size_t posix_thread::hardware_concurrency()
+{
+#if defined(_SC_NPROCESSORS_ONLN)
+  long result = sysconf(_SC_NPROCESSORS_ONLN);
+  if (result > 0)
+    return result;
+#endif // defined(_SC_NPROCESSORS_ONLN)
+  return 0;
+}
+
 void posix_thread::start_thread(func_base* arg)
 {
   int error = ::pthread_create(&thread_, 0,
diff --git a/extern/include/asio/detail/impl/posix_tss_ptr.ipp b/extern/include/asio/detail/impl/posix_tss_ptr.ipp
index 8f39ab23..54b58bd1 100644
--- a/extern/include/asio/detail/impl/posix_tss_ptr.ipp
+++ b/extern/include/asio/detail/impl/posix_tss_ptr.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_tss_ptr.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/impl/reactive_descriptor_service.ipp b/extern/include/asio/detail/impl/reactive_descriptor_service.ipp
index 21138b09..f9505ca9 100644
--- a/extern/include/asio/detail/impl/reactive_descriptor_service.ipp
+++ b/extern/include/asio/detail/impl/reactive_descriptor_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/reactive_descriptor_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -30,13 +30,14 @@ namespace asio {
 namespace detail {
 
 reactive_descriptor_service::reactive_descriptor_service(
-    asio::io_service& io_service)
-  : reactor_(asio::use_service<reactor>(io_service))
+    asio::io_context& io_context)
+  : service_base<reactive_descriptor_service>(io_context),
+    reactor_(asio::use_service<reactor>(io_context))
 {
   reactor_.init_task();
 }
 
-void reactive_descriptor_service::shutdown_service()
+void reactive_descriptor_service::shutdown()
 {
 }
 
@@ -83,14 +84,17 @@ void reactive_descriptor_service::destroy(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("descriptor", &impl, "close"));
+    ASIO_HANDLER_OPERATION((reactor_.context(),
+          "descriptor", &impl, impl.descriptor_, "close"));
 
     reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
         (impl.state_ & descriptor_ops::possible_dup) == 0);
-  }
 
-  asio::error_code ignored_ec;
-  descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
+    asio::error_code ignored_ec;
+    descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
+
+    reactor_.cleanup_descriptor_data(impl.reactor_data_);
+  }
 }
 
 asio::error_code reactive_descriptor_service::assign(
@@ -123,13 +127,20 @@ asio::error_code reactive_descriptor_service::close(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("descriptor", &impl, "close"));
+    ASIO_HANDLER_OPERATION((reactor_.context(),
+          "descriptor", &impl, impl.descriptor_, "close"));
 
     reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
         (impl.state_ & descriptor_ops::possible_dup) == 0);
-  }
 
-  descriptor_ops::close(impl.descriptor_, impl.state_, ec);
+    descriptor_ops::close(impl.descriptor_, impl.state_, ec);
+
+    reactor_.cleanup_descriptor_data(impl.reactor_data_);
+  }
+  else
+  {
+    ec = asio::error_code();
+  }
 
   // The descriptor is closed by the OS even if close() returns an error.
   //
@@ -150,9 +161,11 @@ reactive_descriptor_service::release(
 
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("descriptor", &impl, "release"));
+    ASIO_HANDLER_OPERATION((reactor_.context(),
+          "descriptor", &impl, impl.descriptor_, "release"));
 
     reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false);
+    reactor_.cleanup_descriptor_data(impl.reactor_data_);
     construct(impl);
   }
 
@@ -169,7 +182,8 @@ asio::error_code reactive_descriptor_service::cancel(
     return ec;
   }
 
-  ASIO_HANDLER_OPERATION(("descriptor", &impl, "cancel"));
+  ASIO_HANDLER_OPERATION((reactor_.context(),
+        "descriptor", &impl, impl.descriptor_, "cancel"));
 
   reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
   ec = asio::error_code();
diff --git a/extern/include/asio/detail/impl/reactive_serial_port_service.ipp b/extern/include/asio/detail/impl/reactive_serial_port_service.ipp
index b3ce7b96..c907835c 100644
--- a/extern/include/asio/detail/impl/reactive_serial_port_service.ipp
+++ b/extern/include/asio/detail/impl/reactive_serial_port_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/reactive_serial_port_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -30,14 +30,15 @@ namespace asio {
 namespace detail {
 
 reactive_serial_port_service::reactive_serial_port_service(
-    asio::io_service& io_service)
-  : descriptor_service_(io_service)
+    asio::io_context& io_context)
+  : service_base<reactive_serial_port_service>(io_context),
+    descriptor_service_(io_context)
 {
 }
 
-void reactive_serial_port_service::shutdown_service()
+void reactive_serial_port_service::shutdown()
 {
-  descriptor_service_.shutdown_service();
+  descriptor_service_.shutdown();
 }
 
 asio::error_code reactive_serial_port_service::open(
@@ -72,7 +73,7 @@ asio::error_code reactive_serial_port_service::open(
   s = descriptor_ops::error_wrapper(::tcgetattr(fd, &ios), ec);
   if (s >= 0)
   {
-#if defined(_BSD_SOURCE)
+#if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
     ::cfmakeraw(&ios);
 #else
     ios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK
diff --git a/extern/include/asio/detail/impl/reactive_socket_service_base.ipp b/extern/include/asio/detail/impl/reactive_socket_service_base.ipp
index f6cf62a1..129b851d 100644
--- a/extern/include/asio/detail/impl/reactive_socket_service_base.ipp
+++ b/extern/include/asio/detail/impl/reactive_socket_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,13 +28,14 @@ namespace asio {
 namespace detail {
 
 reactive_socket_service_base::reactive_socket_service_base(
-    asio::io_service& io_service)
-  : reactor_(use_service<reactor>(io_service))
+    asio::io_context& io_context)
+  : io_context_(io_context),
+    reactor_(use_service<reactor>(io_context))
 {
   reactor_.init_task();
 }
 
-void reactive_socket_service_base::shutdown_service()
+void reactive_socket_service_base::base_shutdown()
 {
 }
 
@@ -81,13 +82,16 @@ void reactive_socket_service_base::destroy(
 {
   if (impl.socket_ != invalid_socket)
   {
-    ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+    ASIO_HANDLER_OPERATION((reactor_.context(),
+          "socket", &impl, impl.socket_, "close"));
 
     reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
         (impl.state_ & socket_ops::possible_dup) == 0);
 
     asio::error_code ignored_ec;
     socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
+
+    reactor_.cleanup_descriptor_data(impl.reactor_data_);
   }
 }
 
@@ -97,13 +101,20 @@ asio::error_code reactive_socket_service_base::close(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+    ASIO_HANDLER_OPERATION((reactor_.context(),
+          "socket", &impl, impl.socket_, "close"));
 
     reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
         (impl.state_ & socket_ops::possible_dup) == 0);
-  }
 
-  socket_ops::close(impl.socket_, impl.state_, false, ec);
+    socket_ops::close(impl.socket_, impl.state_, false, ec);
+
+    reactor_.cleanup_descriptor_data(impl.reactor_data_);
+  }
+  else
+  {
+    ec = asio::error_code();
+  }
 
   // The descriptor is closed by the OS even if close() returns an error.
   //
@@ -118,6 +129,27 @@ asio::error_code reactive_socket_service_base::close(
   return ec;
 }
 
+socket_type reactive_socket_service_base::release(
+    reactive_socket_service_base::base_implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return invalid_socket;
+  }
+
+  ASIO_HANDLER_OPERATION((reactor_.context(),
+        "socket", &impl, impl.socket_, "release"));
+
+  reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_, false);
+  reactor_.cleanup_descriptor_data(impl.reactor_data_);
+  socket_type sock = impl.socket_;
+  construct(impl);
+  ec = asio::error_code();
+  return sock;
+}
+
 asio::error_code reactive_socket_service_base::cancel(
     reactive_socket_service_base::base_implementation_type& impl,
     asio::error_code& ec)
@@ -128,7 +160,8 @@ asio::error_code reactive_socket_service_base::cancel(
     return ec;
   }
 
-  ASIO_HANDLER_OPERATION(("socket", &impl, "cancel"));
+  ASIO_HANDLER_OPERATION((reactor_.context(),
+        "socket", &impl, impl.socket_, "cancel"));
 
   reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
   ec = asio::error_code();
@@ -223,7 +256,7 @@ void reactive_socket_service_base::start_accept_op(
     reactor_op* op, bool is_continuation, bool peer_is_open)
 {
   if (!peer_is_open)
-    start_op(impl, reactor::read_op, op, true, is_continuation, false);
+    start_op(impl, reactor::read_op, op, is_continuation, true, false);
   else
   {
     op->ec_ = asio::error::already_open;
diff --git a/extern/include/asio/detail/impl/resolver_service_base.ipp b/extern/include/asio/detail/impl/resolver_service_base.ipp
index 2b1c13ea..540bb66b 100644
--- a/extern/include/asio/detail/impl/resolver_service_base.ipp
+++ b/extern/include/asio/detail/impl/resolver_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/impl/resolver_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,62 +23,62 @@
 namespace asio {
 namespace detail {
 
-class resolver_service_base::work_io_service_runner
+class resolver_service_base::work_io_context_runner
 {
 public:
-  work_io_service_runner(asio::io_service& io_service)
-    : io_service_(io_service) {}
-  void operator()() { io_service_.run(); }
+  work_io_context_runner(asio::io_context& io_context)
+    : io_context_(io_context) {}
+  void operator()() { io_context_.run(); }
 private:
-  asio::io_service& io_service_;
+  asio::io_context& io_context_;
 };
 
 resolver_service_base::resolver_service_base(
-    asio::io_service& io_service)
-  : io_service_impl_(asio::use_service<io_service_impl>(io_service)),
-    work_io_service_(new asio::io_service),
-    work_io_service_impl_(asio::use_service<
-        io_service_impl>(*work_io_service_)),
-    work_(new asio::io_service::work(*work_io_service_)),
+    asio::io_context& io_context)
+  : io_context_impl_(asio::use_service<io_context_impl>(io_context)),
+    work_io_context_(new asio::io_context(-1)),
+    work_io_context_impl_(asio::use_service<
+        io_context_impl>(*work_io_context_)),
+    work_(asio::make_work_guard(*work_io_context_)),
     work_thread_(0)
 {
 }
 
 resolver_service_base::~resolver_service_base()
 {
-  shutdown_service();
+  base_shutdown();
 }
 
-void resolver_service_base::shutdown_service()
+void resolver_service_base::base_shutdown()
 {
   work_.reset();
-  if (work_io_service_.get())
+  if (work_io_context_.get())
   {
-    work_io_service_->stop();
+    work_io_context_->stop();
     if (work_thread_.get())
     {
       work_thread_->join();
       work_thread_.reset();
     }
-    work_io_service_.reset();
+    work_io_context_.reset();
   }
 }
 
-void resolver_service_base::fork_service(
-    asio::io_service::fork_event fork_ev)
+void resolver_service_base::base_notify_fork(
+    asio::io_context::fork_event fork_ev)
 {
   if (work_thread_.get())
   {
-    if (fork_ev == asio::io_service::fork_prepare)
+    if (fork_ev == asio::io_context::fork_prepare)
     {
-      work_io_service_->stop();
+      work_io_context_->stop();
       work_thread_->join();
     }
     else
     {
-      work_io_service_->reset();
+      work_io_context_->restart();
       work_thread_.reset(new asio::detail::thread(
-            work_io_service_runner(*work_io_service_)));
+            work_io_context_runner(*work_io_context_)));
     }
   }
 }
@@ -92,24 +92,48 @@ void resolver_service_base::construct(
 void resolver_service_base::destroy(
     resolver_service_base::implementation_type& impl)
 {
-  ASIO_HANDLER_OPERATION(("resolver", &impl, "cancel"));
+  ASIO_HANDLER_OPERATION((io_context_impl_.context(),
+        "resolver", &impl, 0, "cancel"));
 
   impl.reset();
 }
 
+void resolver_service_base::move_construct(implementation_type& impl,
+    implementation_type& other_impl)
+{
+  impl = ASIO_MOVE_CAST(implementation_type)(other_impl);
+}
+
+void resolver_service_base::move_assign(implementation_type& impl,
+    resolver_service_base&, implementation_type& other_impl)
+{
+  destroy(impl);
+  impl = ASIO_MOVE_CAST(implementation_type)(other_impl);
+}
+
 void resolver_service_base::cancel(
     resolver_service_base::implementation_type& impl)
 {
-  ASIO_HANDLER_OPERATION(("resolver", &impl, "cancel"));
+  ASIO_HANDLER_OPERATION((io_context_impl_.context(),
+        "resolver", &impl, 0, "cancel"));
 
   impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
 }
 
-void resolver_service_base::start_resolve_op(operation* op)
+void resolver_service_base::start_resolve_op(resolve_op* op)
 {
-  start_work_thread();
-  io_service_impl_.work_started();
-  work_io_service_impl_.post_immediate_completion(op, false);
+  if (ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
+        io_context_impl_.concurrency_hint()))
+  {
+    start_work_thread();
+    io_context_impl_.work_started();
+    work_io_context_impl_.post_immediate_completion(op, false);
+  }
+  else
+  {
+    op->ec_ = asio::error::operation_not_supported;
+    io_context_impl_.post_immediate_completion(op, false);
+  }
 }
 
 void resolver_service_base::start_work_thread()
@@ -118,7 +142,7 @@ void resolver_service_base::start_work_thread()
   if (!work_thread_.get())
   {
     work_thread_.reset(new asio::detail::thread(
-          work_io_service_runner(*work_io_service_)));
+          work_io_context_runner(*work_io_context_)));
   }
 }
 
diff --git a/extern/include/asio/detail/impl/task_io_service.ipp b/extern/include/asio/detail/impl/scheduler.ipp
similarity index 58%
rename from extern/include/asio/detail/impl/task_io_service.ipp
rename to extern/include/asio/detail/impl/scheduler.ipp
index 67ba6637..35bc6787 100644
--- a/extern/include/asio/detail/impl/task_io_service.ipp
+++ b/extern/include/asio/detail/impl/scheduler.ipp
@@ -1,15 +1,15 @@
 //
-// detail/impl/task_io_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// detail/impl/scheduler.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
+#ifndef ASIO_DETAIL_IMPL_SCHEDULER_IPP
+#define ASIO_DETAIL_IMPL_SCHEDULER_IPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,27 +17,26 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_HAS_IOCP)
-
+#include "asio/detail/concurrency_hint.hpp"
 #include "asio/detail/event.hpp"
 #include "asio/detail/limits.hpp"
 #include "asio/detail/reactor.hpp"
-#include "asio/detail/task_io_service.hpp"
-#include "asio/detail/task_io_service_thread_info.hpp"
+#include "asio/detail/scheduler.hpp"
+#include "asio/detail/scheduler_thread_info.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-struct task_io_service::task_cleanup
+struct scheduler::task_cleanup
 {
   ~task_cleanup()
   {
     if (this_thread_->private_outstanding_work > 0)
     {
       asio::detail::increment(
-          task_io_service_->outstanding_work_,
+          scheduler_->outstanding_work_,
           this_thread_->private_outstanding_work);
     }
     this_thread_->private_outstanding_work = 0;
@@ -45,29 +44,29 @@ struct task_io_service::task_cleanup
     // Enqueue the completed operations and reinsert the task at the end of
     // the operation queue.
     lock_->lock();
-    task_io_service_->task_interrupted_ = true;
-    task_io_service_->op_queue_.push(this_thread_->private_op_queue);
-    task_io_service_->op_queue_.push(&task_io_service_->task_operation_);
+    scheduler_->task_interrupted_ = true;
+    scheduler_->op_queue_.push(this_thread_->private_op_queue);
+    scheduler_->op_queue_.push(&scheduler_->task_operation_);
   }
 
-  task_io_service* task_io_service_;
+  scheduler* scheduler_;
   mutex::scoped_lock* lock_;
   thread_info* this_thread_;
 };
 
-struct task_io_service::work_cleanup
+struct scheduler::work_cleanup
 {
   ~work_cleanup()
   {
     if (this_thread_->private_outstanding_work > 1)
     {
       asio::detail::increment(
-          task_io_service_->outstanding_work_,
+          scheduler_->outstanding_work_,
           this_thread_->private_outstanding_work - 1);
     }
     else if (this_thread_->private_outstanding_work < 1)
     {
-      task_io_service_->work_finished();
+      scheduler_->work_finished();
     }
     this_thread_->private_outstanding_work = 0;
 
@@ -75,31 +74,37 @@ struct task_io_service::work_cleanup
     if (!this_thread_->private_op_queue.empty())
     {
       lock_->lock();
-      task_io_service_->op_queue_.push(this_thread_->private_op_queue);
+      scheduler_->op_queue_.push(this_thread_->private_op_queue);
     }
 #endif // defined(ASIO_HAS_THREADS)
   }
 
-  task_io_service* task_io_service_;
+  scheduler* scheduler_;
   mutex::scoped_lock* lock_;
   thread_info* this_thread_;
 };
 
-task_io_service::task_io_service(
-    asio::io_service& io_service, std::size_t concurrency_hint)
-  : asio::detail::service_base<task_io_service>(io_service),
-    one_thread_(concurrency_hint == 1),
-    mutex_(),
+scheduler::scheduler(
+    asio::execution_context& ctx, int concurrency_hint)
+  : asio::detail::execution_context_service_base<scheduler>(ctx),
+    one_thread_(concurrency_hint == 1
+        || !ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          SCHEDULER, concurrency_hint)
+        || !ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          REACTOR_IO, concurrency_hint)),
+    mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          SCHEDULER, concurrency_hint)),
     task_(0),
     task_interrupted_(true),
     outstanding_work_(0),
     stopped_(false),
-    shutdown_(false)
+    shutdown_(false),
+    concurrency_hint_(concurrency_hint)
 {
   ASIO_HANDLER_TRACKING_INIT;
 }
 
-void task_io_service::shutdown_service()
+void scheduler::shutdown()
 {
   mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
@@ -118,18 +123,18 @@ void task_io_service::shutdown_service()
   task_ = 0;
 }
 
-void task_io_service::init_task()
+void scheduler::init_task()
 {
   mutex::scoped_lock lock(mutex_);
   if (!shutdown_ && !task_)
   {
-    task_ = &use_service<reactor>(this->get_io_service());
+    task_ = &use_service<reactor>(this->context());
     op_queue_.push(&task_operation_);
     wake_one_thread_and_unlock(lock);
   }
 }
 
-std::size_t task_io_service::run(asio::error_code& ec)
+std::size_t scheduler::run(asio::error_code& ec)
 {
   ec = asio::error_code();
   if (outstanding_work_ == 0)
@@ -151,7 +156,7 @@ std::size_t task_io_service::run(asio::error_code& ec)
   return n;
 }
 
-std::size_t task_io_service::run_one(asio::error_code& ec)
+std::size_t scheduler::run_one(asio::error_code& ec)
 {
   ec = asio::error_code();
   if (outstanding_work_ == 0)
@@ -169,7 +174,25 @@ std::size_t task_io_service::run_one(asio::error_code& ec)
   return do_run_one(lock, this_thread, ec);
 }
 
-std::size_t task_io_service::poll(asio::error_code& ec)
+std::size_t scheduler::wait_one(long usec, asio::error_code& ec)
+{
+  ec = asio::error_code();
+  if (outstanding_work_ == 0)
+  {
+    stop();
+    return 0;
+  }
+
+  thread_info this_thread;
+  this_thread.private_outstanding_work = 0;
+  thread_call_stack::context ctx(this, this_thread);
+
+  mutex::scoped_lock lock(mutex_);
+
+  return do_wait_one(lock, this_thread, usec, ec);
+}
+
+std::size_t scheduler::poll(asio::error_code& ec)
 {
   ec = asio::error_code();
   if (outstanding_work_ == 0)
@@ -189,8 +212,8 @@ std::size_t task_io_service::poll(asio::error_code& ec)
   // that are already on a thread-private queue need to be put on to the main
   // queue now.
   if (one_thread_)
-    if (thread_info* outer_thread_info = ctx.next_by_key())
-      op_queue_.push(outer_thread_info->private_op_queue);
+    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
+      op_queue_.push(outer_info->private_op_queue);
 #endif // defined(ASIO_HAS_THREADS)
 
   std::size_t n = 0;
@@ -200,7 +223,7 @@ std::size_t task_io_service::poll(asio::error_code& ec)
   return n;
 }
 
-std::size_t task_io_service::poll_one(asio::error_code& ec)
+std::size_t scheduler::poll_one(asio::error_code& ec)
 {
   ec = asio::error_code();
   if (outstanding_work_ == 0)
@@ -220,41 +243,47 @@ std::size_t task_io_service::poll_one(asio::error_code& ec)
   // that are already on a thread-private queue need to be put on to the main
   // queue now.
   if (one_thread_)
-    if (thread_info* outer_thread_info = ctx.next_by_key())
-      op_queue_.push(outer_thread_info->private_op_queue);
+    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
+      op_queue_.push(outer_info->private_op_queue);
 #endif // defined(ASIO_HAS_THREADS)
 
   return do_poll_one(lock, this_thread, ec);
 }
 
-void task_io_service::stop()
+void scheduler::stop()
 {
   mutex::scoped_lock lock(mutex_);
   stop_all_threads(lock);
 }
 
-bool task_io_service::stopped() const
+bool scheduler::stopped() const
 {
   mutex::scoped_lock lock(mutex_);
   return stopped_;
 }
 
-void task_io_service::reset()
+void scheduler::restart()
 {
   mutex::scoped_lock lock(mutex_);
   stopped_ = false;
 }
 
-void task_io_service::post_immediate_completion(
-    task_io_service::operation* op, bool is_continuation)
+void scheduler::compensating_work_started()
+{
+  thread_info_base* this_thread = thread_call_stack::contains(this);
+  ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
+}
+
+void scheduler::post_immediate_completion(
+    scheduler::operation* op, bool is_continuation)
 {
 #if defined(ASIO_HAS_THREADS)
   if (one_thread_ || is_continuation)
   {
-    if (thread_info* this_thread = thread_call_stack::contains(this))
+    if (thread_info_base* this_thread = thread_call_stack::contains(this))
     {
-      ++this_thread->private_outstanding_work;
-      this_thread->private_op_queue.push(op);
+      ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
+      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
       return;
     }
   }
@@ -268,14 +297,14 @@ void task_io_service::post_immediate_completion(
   wake_one_thread_and_unlock(lock);
 }
 
-void task_io_service::post_deferred_completion(task_io_service::operation* op)
+void scheduler::post_deferred_completion(scheduler::operation* op)
 {
 #if defined(ASIO_HAS_THREADS)
   if (one_thread_)
   {
-    if (thread_info* this_thread = thread_call_stack::contains(this))
+    if (thread_info_base* this_thread = thread_call_stack::contains(this))
     {
-      this_thread->private_op_queue.push(op);
+      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
       return;
     }
   }
@@ -286,17 +315,17 @@ void task_io_service::post_deferred_completion(task_io_service::operation* op)
   wake_one_thread_and_unlock(lock);
 }
 
-void task_io_service::post_deferred_completions(
-    op_queue<task_io_service::operation>& ops)
+void scheduler::post_deferred_completions(
+    op_queue<scheduler::operation>& ops)
 {
   if (!ops.empty())
   {
 #if defined(ASIO_HAS_THREADS)
     if (one_thread_)
     {
-      if (thread_info* this_thread = thread_call_stack::contains(this))
+      if (thread_info_base* this_thread = thread_call_stack::contains(this))
       {
-        this_thread->private_op_queue.push(ops);
+        static_cast<thread_info*>(this_thread)->private_op_queue.push(ops);
         return;
       }
     }
@@ -308,8 +337,8 @@ void task_io_service::post_deferred_completions(
   }
 }
 
-void task_io_service::do_dispatch(
-    task_io_service::operation* op)
+void scheduler::do_dispatch(
+    scheduler::operation* op)
 {
   work_started();
   mutex::scoped_lock lock(mutex_);
@@ -317,15 +346,15 @@ void task_io_service::do_dispatch(
   wake_one_thread_and_unlock(lock);
 }
 
-void task_io_service::abandon_operations(
-    op_queue<task_io_service::operation>& ops)
+void scheduler::abandon_operations(
+    op_queue<scheduler::operation>& ops)
 {
-  op_queue<task_io_service::operation> ops2;
+  op_queue<scheduler::operation> ops2;
   ops2.push(ops);
 }
 
-std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
-    task_io_service::thread_info& this_thread,
+std::size_t scheduler::do_run_one(mutex::scoped_lock& lock,
+    scheduler::thread_info& this_thread,
     const asio::error_code& ec)
 {
   while (!stopped_)
@@ -352,7 +381,7 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
         // Run the task. May throw an exception. Only block if the operation
         // queue is empty and we're not polling, otherwise we want to return
         // as soon as possible.
-        task_->run(!more_handlers, this_thread.private_op_queue);
+        task_->run(more_handlers ? 0 : -1, this_thread.private_op_queue);
       }
       else
       {
@@ -368,7 +397,7 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
         (void)on_exit;
 
         // Complete the operation. May throw an exception. Deletes the object.
-        o->complete(*this, ec, task_result);
+        o->complete(this, ec, task_result);
 
         return 1;
       }
@@ -383,8 +412,78 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
   return 0;
 }
 
-std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
-    task_io_service::thread_info& this_thread,
+std::size_t scheduler::do_wait_one(mutex::scoped_lock& lock,
+    scheduler::thread_info& this_thread, long usec,
+    const asio::error_code& ec)
+{
+  if (stopped_)
+    return 0;
+
+  operation* o = op_queue_.front();
+  if (o == 0)
+  {
+    wakeup_event_.clear(lock);
+    wakeup_event_.wait_for_usec(lock, usec);
+    usec = 0; // Wait at most once.
+    o = op_queue_.front();
+  }
+
+  if (o == &task_operation_)
+  {
+    op_queue_.pop();
+    bool more_handlers = (!op_queue_.empty());
+
+    task_interrupted_ = more_handlers;
+
+    if (more_handlers && !one_thread_)
+      wakeup_event_.unlock_and_signal_one(lock);
+    else
+      lock.unlock();
+
+    {
+      task_cleanup on_exit = { this, &lock, &this_thread };
+      (void)on_exit;
+
+      // Run the task. May throw an exception. Only block if the operation
+      // queue is empty and we're not polling, otherwise we want to return
+      // as soon as possible.
+      task_->run(more_handlers ? 0 : usec, this_thread.private_op_queue);
+    }
+
+    o = op_queue_.front();
+    if (o == &task_operation_)
+    {
+      if (!one_thread_)
+        wakeup_event_.maybe_unlock_and_signal_one(lock);
+      return 0;
+    }
+  }
+
+  if (o == 0)
+    return 0;
+
+  op_queue_.pop();
+  bool more_handlers = (!op_queue_.empty());
+
+  std::size_t task_result = o->task_result_;
+
+  if (more_handlers && !one_thread_)
+    wake_one_thread_and_unlock(lock);
+  else
+    lock.unlock();
+
+  // Ensure the count of outstanding work is decremented on block exit.
+  work_cleanup on_exit = { this, &lock, &this_thread };
+  (void)on_exit;
+
+  // Complete the operation. May throw an exception. Deletes the object.
+  o->complete(this, ec, task_result);
+
+  return 1;
+}
+
+std::size_t scheduler::do_poll_one(mutex::scoped_lock& lock,
+    scheduler::thread_info& this_thread,
     const asio::error_code& ec)
 {
   if (stopped_)
@@ -403,7 +502,7 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
       // Run the task. May throw an exception. Only block if the operation
       // queue is empty and we're not polling, otherwise we want to return
       // as soon as possible.
-      task_->run(false, this_thread.private_op_queue);
+      task_->run(0, this_thread.private_op_queue);
     }
 
     o = op_queue_.front();
@@ -432,12 +531,12 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
   (void)on_exit;
 
   // Complete the operation. May throw an exception. Deletes the object.
-  o->complete(*this, ec, task_result);
+  o->complete(this, ec, task_result);
 
   return 1;
 }
 
-void task_io_service::stop_all_threads(
+void scheduler::stop_all_threads(
     mutex::scoped_lock& lock)
 {
   stopped_ = true;
@@ -450,7 +549,7 @@ void task_io_service::stop_all_threads(
   }
 }
 
-void task_io_service::wake_one_thread_and_unlock(
+void scheduler::wake_one_thread_and_unlock(
     mutex::scoped_lock& lock)
 {
   if (!wakeup_event_.maybe_unlock_and_signal_one(lock))
@@ -469,6 +568,4 @@ void task_io_service::wake_one_thread_and_unlock(
 
 #include "asio/detail/pop_options.hpp"
 
-#endif // !defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
+#endif // ASIO_DETAIL_IMPL_SCHEDULER_IPP
diff --git a/extern/include/asio/detail/impl/select_reactor.hpp b/extern/include/asio/detail/impl/select_reactor.hpp
index c67292a4..04a04d49 100644
--- a/extern/include/asio/detail/impl/select_reactor.hpp
+++ b/extern/include/asio/detail/impl/select_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/select_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -50,12 +50,12 @@ void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op, false);
+    scheduler_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
+  scheduler_.work_started();
   if (earliest)
     interrupter_.interrupt();
 }
@@ -69,10 +69,23 @@ std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   op_queue<operation> ops;
   std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
   return n;
 }
 
+template <typename Time_Traits>
+void select_reactor::move_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& target,
+    typename timer_queue<Time_Traits>::per_timer_data& source)
+{
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer(target, ops);
+  queue.move_timer(target, source);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 } // namespace detail
 } // namespace asio
 
diff --git a/extern/include/asio/detail/impl/select_reactor.ipp b/extern/include/asio/detail/impl/select_reactor.ipp
index 2bd50dd6..262bc698 100644
--- a/extern/include/asio/detail/impl/select_reactor.ipp
+++ b/extern/include/asio/detail/impl/select_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/select_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,7 +23,6 @@
       && !defined(ASIO_HAS_KQUEUE) \
       && !defined(ASIO_WINDOWS_RUNTIME))
 
-#include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fd_set_adapter.hpp"
 #include "asio/detail/select_reactor.hpp"
 #include "asio/detail/signal_blocker.hpp"
@@ -34,9 +33,28 @@
 namespace asio {
 namespace detail {
 
-select_reactor::select_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<select_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
+#if defined(ASIO_HAS_IOCP)
+class select_reactor::thread_function
+{
+public:
+  explicit thread_function(select_reactor* r)
+    : this_(r)
+  {
+  }
+
+  void operator()()
+  {
+    this_->run_thread();
+  }
+
+private:
+  select_reactor* this_;
+};
+#endif // defined(ASIO_HAS_IOCP)
+
+select_reactor::select_reactor(asio::execution_context& ctx)
+  : execution_context_service_base<select_reactor>(ctx),
+    scheduler_(use_service<scheduler_type>(ctx)),
     mutex_(),
     interrupter_(),
 #if defined(ASIO_HAS_IOCP)
@@ -47,17 +65,16 @@ select_reactor::select_reactor(asio::io_service& io_service)
 {
 #if defined(ASIO_HAS_IOCP)
   asio::detail::signal_blocker sb;
-  thread_ = new asio::detail::thread(
-      bind_handler(&select_reactor::call_run_thread, this));
+  thread_ = new asio::detail::thread(thread_function(this));
 #endif // defined(ASIO_HAS_IOCP)
 }
 
 select_reactor::~select_reactor()
 {
-  shutdown_service();
+  shutdown();
 }
 
-void select_reactor::shutdown_service()
+void select_reactor::shutdown()
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
@@ -83,18 +100,19 @@ void select_reactor::shutdown_service()
 
   timer_queues_.get_all_timers(ops);
 
-  io_service_.abandon_operations(ops);
+  scheduler_.abandon_operations(ops);
 }
 
-void select_reactor::fork_service(asio::io_service::fork_event fork_ev)
+void select_reactor::notify_fork(
+    asio::execution_context::fork_event fork_ev)
 {
-  if (fork_ev == asio::io_service::fork_child)
+  if (fork_ev == asio::execution_context::fork_child)
     interrupter_.recreate();
 }
 
 void select_reactor::init_task()
 {
-  io_service_.init_task();
+  scheduler_.init_task();
 }
 
 int select_reactor::register_descriptor(socket_type,
@@ -134,7 +152,7 @@ void select_reactor::start_op(int op_type, socket_type descriptor,
   }
 
   bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-  io_service_.work_started();
+  scheduler_.work_started();
   if (first)
     interrupter_.interrupt();
 }
@@ -162,7 +180,12 @@ void select_reactor::deregister_internal_descriptor(
     op_queue_[i].cancel_operations(descriptor, ops);
 }
 
-void select_reactor::run(bool block, op_queue<operation>& ops)
+void select_reactor::cleanup_descriptor_data(
+    select_reactor::per_descriptor_data&)
+{
+}
+
+void select_reactor::run(long usec, op_queue<operation>& ops)
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
 
@@ -199,12 +222,12 @@ void select_reactor::run(bool block, op_queue<operation>& ops)
 
   // We can return immediately if there's no work to do and the reactor is
   // not supposed to block.
-  if (!block && !have_work_to_do)
+  if (!usec && !have_work_to_do)
     return;
 
   // Determine how long to block while waiting for events.
   timeval tv_buf = { 0, 0 };
-  timeval* tv = block ? get_timeout(tv_buf) : &tv_buf;
+  timeval* tv = usec ? get_timeout(usec, tv_buf) : &tv_buf;
 
   lock.unlock();
 
@@ -253,15 +276,10 @@ void select_reactor::run_thread()
     lock.unlock();
     op_queue<operation> ops;
     run(true, ops);
-    io_service_.post_deferred_completions(ops);
+    scheduler_.post_deferred_completions(ops);
     lock.lock();
   }
 }
-
-void select_reactor::call_run_thread(select_reactor* reactor)
-{
-  reactor->run_thread();
-}
 #endif // defined(ASIO_HAS_IOCP)
 
 void select_reactor::do_add_timer_queue(timer_queue_base& queue)
@@ -276,11 +294,13 @@ void select_reactor::do_remove_timer_queue(timer_queue_base& queue)
   timer_queues_.erase(&queue);
 }
 
-timeval* select_reactor::get_timeout(timeval& tv)
+timeval* select_reactor::get_timeout(long usec, timeval& tv)
 {
   // By default we will wait no longer than 5 minutes. This will ensure that
   // any changes to the system clock are detected after no longer than this.
-  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
+  const long max_usec = 5 * 60 * 1000 * 1000;
+  usec = timer_queues_.wait_duration_usec(
+      (usec < 0 || max_usec < usec) ? max_usec : usec);
   tv.tv_sec = usec / 1000000;
   tv.tv_usec = usec % 1000000;
   return &tv;
@@ -294,7 +314,7 @@ void select_reactor::cancel_ops_unlocked(socket_type descriptor,
   for (int i = 0; i < max_ops; ++i)
     need_interrupt = op_queue_[i].cancel_operations(
         descriptor, ops, ec) || need_interrupt;
-  io_service_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
   if (need_interrupt)
     interrupter_.interrupt();
 }
diff --git a/extern/include/asio/detail/impl/service_registry.hpp b/extern/include/asio/detail/impl/service_registry.hpp
index 90cfaa89..d4db5899 100644
--- a/extern/include/asio/detail/impl/service_registry.hpp
+++ b/extern/include/asio/detail/impl/service_registry.hpp
@@ -2,7 +2,7 @@
 // detail/impl/service_registry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,64 +20,70 @@
 namespace asio {
 namespace detail {
 
-template <typename Service, typename Arg>
-service_registry::service_registry(
-    asio::io_service& o, Service*, Arg arg)
-  : owner_(o),
-    first_service_(new Service(o, arg))
-{
-  asio::io_service::service::key key;
-  init_key(key, Service::id);
-  first_service_->key_ = key;
-  first_service_->next_ = 0;
-}
-
 template <typename Service>
-Service& service_registry::first_service()
+Service& service_registry::use_service()
 {
-  return *static_cast<Service*>(first_service_);
+  execution_context::service::key key;
+  init_key<Service>(key, 0);
+  factory_type factory = &service_registry::create<Service, execution_context>;
+  return *static_cast<Service*>(do_use_service(key, factory, &owner_));
 }
 
 template <typename Service>
-Service& service_registry::use_service()
+Service& service_registry::use_service(io_context& owner)
 {
-  asio::io_service::service::key key;
-  init_key(key, Service::id);
-  factory_type factory = &service_registry::create<Service>;
-  return *static_cast<Service*>(do_use_service(key, factory));
+  execution_context::service::key key;
+  init_key<Service>(key, 0);
+  factory_type factory = &service_registry::create<Service, io_context>;
+  return *static_cast<Service*>(do_use_service(key, factory, &owner));
 }
 
 template <typename Service>
 void service_registry::add_service(Service* new_service)
 {
-  asio::io_service::service::key key;
-  init_key(key, Service::id);
+  execution_context::service::key key;
+  init_key<Service>(key, 0);
   return do_add_service(key, new_service);
 }
 
 template <typename Service>
 bool service_registry::has_service() const
 {
-  asio::io_service::service::key key;
-  init_key(key, Service::id);
+  execution_context::service::key key;
+  init_key<Service>(key, 0);
   return do_has_service(key);
 }
 
+template <typename Service>
+inline void service_registry::init_key(
+    execution_context::service::key& key, ...)
+{
+  init_key_from_id(key, Service::id);
+}
+
 #if !defined(ASIO_NO_TYPEID)
 template <typename Service>
-void service_registry::init_key(asio::io_service::service::key& key,
-    const asio::detail::service_id<Service>& /*id*/)
+void service_registry::init_key(execution_context::service::key& key,
+    typename enable_if<
+      is_base_of<typename Service::key_type, Service>::value>::type*)
 {
   key.type_info_ = &typeid(typeid_wrapper<Service>);
   key.id_ = 0;
 }
-#endif // !defined(ASIO_NO_TYPEID)
 
 template <typename Service>
-asio::io_service::service* service_registry::create(
-    asio::io_service& owner)
+void service_registry::init_key_from_id(execution_context::service::key& key,
+    const service_id<Service>& /*id*/)
+{
+  key.type_info_ = &typeid(typeid_wrapper<Service>);
+  key.id_ = 0;
+}
+#endif // !defined(ASIO_NO_TYPEID)
+
+template <typename Service, typename Owner>
+execution_context::service* service_registry::create(void* owner)
 {
-  return new Service(owner);
+  return new Service(*static_cast<Owner*>(owner));
 }
 
 } // namespace detail
diff --git a/extern/include/asio/detail/impl/service_registry.ipp b/extern/include/asio/detail/impl/service_registry.ipp
index b7358c5d..a4650332 100644
--- a/extern/include/asio/detail/impl/service_registry.ipp
+++ b/extern/include/asio/detail/impl/service_registry.ipp
@@ -2,7 +2,7 @@
 // detail/impl/service_registry.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,36 +25,45 @@
 namespace asio {
 namespace detail {
 
+service_registry::service_registry(execution_context& owner)
+  : owner_(owner),
+    first_service_(0)
+{
+}
+
 service_registry::~service_registry()
 {
-  // Shutdown all services. This must be done in a separate loop before the
-  // services are destroyed since the destructors of user-defined handler
-  // objects may try to access other service objects.
-  asio::io_service::service* service = first_service_;
+}
+
+void service_registry::shutdown_services()
+{
+  execution_context::service* service = first_service_;
   while (service)
   {
-    service->shutdown_service();
+    service->shutdown();
     service = service->next_;
   }
+}
 
-  // Destroy all services.
+void service_registry::destroy_services()
+{
   while (first_service_)
   {
-    asio::io_service::service* next_service = first_service_->next_;
+    execution_context::service* next_service = first_service_->next_;
     destroy(first_service_);
     first_service_ = next_service;
   }
 }
 
-void service_registry::notify_fork(asio::io_service::fork_event fork_ev)
+void service_registry::notify_fork(execution_context::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<asio::io_service::service*> services;
+  std::vector<execution_context::service*> services;
   {
     asio::detail::mutex::scoped_lock lock(mutex_);
-    asio::io_service::service* service = first_service_;
+    execution_context::service* service = first_service_;
     while (service)
     {
       services.push_back(service);
@@ -67,24 +76,24 @@ void service_registry::notify_fork(asio::io_service::fork_event fork_ev)
   // 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 == asio::io_service::fork_prepare)
+  if (fork_ev == execution_context::fork_prepare)
     for (std::size_t i = 0; i < num_services; ++i)
-      services[i]->fork_service(fork_ev);
+      services[i]->notify_fork(fork_ev);
   else
     for (std::size_t i = num_services; i > 0; --i)
-      services[i - 1]->fork_service(fork_ev);
+      services[i - 1]->notify_fork(fork_ev);
 }
 
-void service_registry::init_key(asio::io_service::service::key& key,
-    const asio::io_service::id& id)
+void service_registry::init_key_from_id(execution_context::service::key& key,
+    const execution_context::id& id)
 {
   key.type_info_ = 0;
   key.id_ = &id;
 }
 
 bool service_registry::keys_match(
-    const asio::io_service::service::key& key1,
-    const asio::io_service::service::key& key2)
+    const execution_context::service::key& key1,
+    const execution_context::service::key& key2)
 {
   if (key1.id_ && key2.id_)
     if (key1.id_ == key2.id_)
@@ -95,19 +104,19 @@ bool service_registry::keys_match(
   return false;
 }
 
-void service_registry::destroy(asio::io_service::service* service)
+void service_registry::destroy(execution_context::service* service)
 {
   delete service;
 }
 
-asio::io_service::service* service_registry::do_use_service(
-    const asio::io_service::service::key& key,
-    factory_type factory)
+execution_context::service* service_registry::do_use_service(
+    const execution_context::service::key& key,
+    factory_type factory, void* owner)
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
 
   // First see if there is an existing service object with the given key.
-  asio::io_service::service* service = first_service_;
+  execution_context::service* service = first_service_;
   while (service)
   {
     if (keys_match(service->key_, key))
@@ -119,7 +128,7 @@ asio::io_service::service* service_registry::do_use_service(
   // at this time to allow for nested calls into this function from the new
   // service's constructor.
   lock.unlock();
-  auto_service_ptr new_service = { factory(owner_) };
+  auto_service_ptr new_service = { factory(owner) };
   new_service.ptr_->key_ = key;
   lock.lock();
 
@@ -141,16 +150,16 @@ asio::io_service::service* service_registry::do_use_service(
 }
 
 void service_registry::do_add_service(
-    const asio::io_service::service::key& key,
-    asio::io_service::service* new_service)
+    const execution_context::service::key& key,
+    execution_context::service* new_service)
 {
-  if (&owner_ != &new_service->get_io_service())
+  if (&owner_ != &new_service->context())
     asio::detail::throw_exception(invalid_service_owner());
 
   asio::detail::mutex::scoped_lock lock(mutex_);
 
   // Check if there is an existing service object with the given key.
-  asio::io_service::service* service = first_service_;
+  execution_context::service* service = first_service_;
   while (service)
   {
     if (keys_match(service->key_, key))
@@ -165,11 +174,11 @@ void service_registry::do_add_service(
 }
 
 bool service_registry::do_has_service(
-    const asio::io_service::service::key& key) const
+    const execution_context::service::key& key) const
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
 
-  asio::io_service::service* service = first_service_;
+  execution_context::service* service = first_service_;
   while (service)
   {
     if (keys_match(service->key_, key))
diff --git a/extern/include/asio/detail/impl/signal_set_service.ipp b/extern/include/asio/detail/impl/signal_set_service.ipp
index 1b00dc36..dd68fc15 100644
--- a/extern/include/asio/detail/impl/signal_set_service.ipp
+++ b/extern/include/asio/detail/impl/signal_set_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/signal_set_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,10 +18,12 @@
 #include "asio/detail/config.hpp"
 
 #include <cstring>
+#include <stdexcept>
 #include "asio/detail/reactor.hpp"
 #include "asio/detail/signal_blocker.hpp"
 #include "asio/detail/signal_set_service.hpp"
 #include "asio/detail/static_mutex.hpp"
+#include "asio/detail/throw_exception.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -91,7 +93,7 @@ public:
   {
   }
 
-  static bool do_perform(reactor_op*)
+  static status do_perform(reactor_op*)
   {
     signal_state* state = get_signal_state();
 
@@ -101,10 +103,10 @@ public:
       if (signal_number >= 0 && signal_number < max_signal_number)
         signal_set_service::deliver_signal(signal_number);
 
-    return false;
+    return not_done;
   }
 
-  static void do_complete(io_service_impl* /*owner*/, operation* base,
+  static void do_complete(void* /*owner*/, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
@@ -117,12 +119,13 @@ public:
        //   && !defined(__CYGWIN__)
 
 signal_set_service::signal_set_service(
-    asio::io_service& io_service)
-  : io_service_(asio::use_service<io_service_impl>(io_service)),
+    asio::io_context& io_context)
+  : service_base<signal_set_service>(io_context),
+    io_context_(asio::use_service<io_context_impl>(io_context)),
 #if !defined(ASIO_WINDOWS) \
   && !defined(ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
-    reactor_(asio::use_service<reactor>(io_service)),
+    reactor_(asio::use_service<reactor>(io_context)),
 #endif // !defined(ASIO_WINDOWS)
        //   && !defined(ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -150,7 +153,7 @@ signal_set_service::~signal_set_service()
   remove_service(this);
 }
 
-void signal_set_service::shutdown_service()
+void signal_set_service::shutdown()
 {
   remove_service(this);
 
@@ -166,11 +169,11 @@ void signal_set_service::shutdown_service()
     }
   }
 
-  io_service_.abandon_operations(ops);
+  io_context_.abandon_operations(ops);
 }
 
-void signal_set_service::fork_service(
-    asio::io_service::fork_event fork_ev)
+void signal_set_service::notify_fork(
+    asio::io_context::fork_event fork_ev)
 {
 #if !defined(ASIO_WINDOWS) \
   && !defined(ASIO_WINDOWS_RUNTIME) \
@@ -180,15 +183,16 @@ void signal_set_service::fork_service(
 
   switch (fork_ev)
   {
-  case asio::io_service::fork_prepare:
+  case asio::io_context::fork_prepare:
     {
       int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = true;
       lock.unlock();
       reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
+      reactor_.cleanup_descriptor_data(reactor_data_);
     }
     break;
-  case asio::io_service::fork_parent:
+  case asio::io_context::fork_parent:
     if (state->fork_prepared_)
     {
       int read_descriptor = state->read_descriptor_;
@@ -198,7 +202,7 @@ void signal_set_service::fork_service(
           read_descriptor, reactor_data_, new pipe_read_op);
     }
     break;
-  case asio::io_service::fork_child:
+  case asio::io_context::fork_child:
     if (state->fork_prepared_)
     {
       asio::detail::signal_blocker blocker;
@@ -437,7 +441,8 @@ asio::error_code signal_set_service::cancel(
     signal_set_service::implementation_type& impl,
     asio::error_code& ec)
 {
-  ASIO_HANDLER_OPERATION(("signal_set", &impl, "cancel"));
+  ASIO_HANDLER_OPERATION((io_context_.context(),
+        "signal_set", &impl, 0, "cancel"));
 
   op_queue<operation> ops;
   {
@@ -452,7 +457,7 @@ asio::error_code signal_set_service::cancel(
     }
   }
 
-  io_service_.post_deferred_completions(ops);
+  io_context_.post_deferred_completions(ops);
 
   ec = asio::error_code();
   return ec;
@@ -488,7 +493,7 @@ void signal_set_service::deliver_signal(int signal_number)
       reg = reg->next_in_table_;
     }
 
-    service->io_service_.post_deferred_completions(ops);
+    service->io_context_.post_deferred_completions(ops);
 
     service = service->next_;
   }
@@ -505,6 +510,22 @@ void signal_set_service::add_service(signal_set_service* service)
     open_descriptors();
 #endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
 
+  // If an io_context object is thread-unsafe then it must be the only
+  // io_context used to create signal_set objects.
+  if (state->service_list_ != 0)
+  {
+    if (!ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
+          service->io_context_.concurrency_hint())
+        || !ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
+          state->service_list_->io_context_.concurrency_hint()))
+    {
+      std::logic_error ex(
+          "Thread-unsafe io_context objects require "
+          "exclusive access to signal handling.");
+      asio::detail::throw_exception(ex);
+    }
+  }
+
   // Insert service into linked list of all services.
   service->next_ = state->service_list_;
   service->prev_ = 0;
@@ -538,8 +559,9 @@ void signal_set_service::remove_service(signal_set_service* service)
     // Disable the pipe readiness notifications.
     int read_descriptor = state->read_descriptor_;
     lock.unlock();
-    service->reactor_.deregister_descriptor(
-        read_descriptor, service->reactor_data_, false);
+    service->reactor_.deregister_internal_descriptor(
+        read_descriptor, service->reactor_data_);
+    service->reactor_.cleanup_descriptor_data(service->reactor_data_);
     lock.lock();
 #endif // !defined(ASIO_WINDOWS)
        //   && !defined(ASIO_WINDOWS_RUNTIME)
@@ -617,7 +639,7 @@ void signal_set_service::close_descriptors()
 void signal_set_service::start_wait_op(
     signal_set_service::implementation_type& impl, signal_op* op)
 {
-  io_service_.work_started();
+  io_context_.work_started();
 
   signal_state* state = get_signal_state();
   static_mutex::scoped_lock lock(state->mutex_);
@@ -629,7 +651,7 @@ void signal_set_service::start_wait_op(
     {
       --reg->undelivered_;
       op->signal_number_ = reg->signal_number_;
-      io_service_.post_deferred_completion(op);
+      io_context_.post_deferred_completion(op);
       return;
     }
 
diff --git a/extern/include/asio/detail/impl/socket_ops.ipp b/extern/include/asio/detail/impl/socket_ops.ipp
index 6d3de489..5e747332 100644
--- a/extern/include/asio/detail/impl/socket_ops.ipp
+++ b/extern/include/asio/detail/impl/socket_ops.ipp
@@ -2,7 +2,7 @@
 // detail/impl/socket_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -168,7 +168,7 @@ socket_type sync_accept(socket_type s, state_type state,
       return invalid_socket;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
+    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return invalid_socket;
   }
 }
@@ -241,8 +241,6 @@ bool non_blocking_accept(socket_type s,
     if (ec == asio::error::would_block
         || ec == asio::error::try_again)
     {
-      if (state & user_set_non_blocking)
-        return true;
       // Fall through to retry operation.
     }
     else if (ec == asio::error::connection_aborted)
@@ -505,7 +503,7 @@ void sync_connect(socket_type s, const socket_addr_type* addr,
   }
 
   // Wait for socket to become ready.
-  if (socket_ops::poll_connect(s, ec) < 0)
+  if (socket_ops::poll_connect(s, -1, ec) < 0)
     return;
 
   // Get the error code from the connect operation.
@@ -772,6 +770,8 @@ signed_size_type recv(socket_type s, buf* bufs, size_t count,
     ec = asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = asio::error::connection_refused;
+  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
+    ec.assign(0, ec.category());
   if (result != 0)
     return socket_error_retval;
   ec = asio::error_code();
@@ -827,7 +827,7 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs,
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
+    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
@@ -850,6 +850,10 @@ void complete_iocp_recv(state_type state,
   {
     ec = asio::error::connection_refused;
   }
+  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
+  {
+    ec.assign(0, ec.category());
+  }
 
   // Check for connection closed.
   else if (!ec && bytes_transferred == 0
@@ -920,6 +924,8 @@ signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
     ec = asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = asio::error::connection_refused;
+  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
+    ec.assign(0, ec.category());
   if (result != 0)
     return socket_error_retval;
   ec = asio::error_code();
@@ -966,7 +972,7 @@ size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
+    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
@@ -989,6 +995,10 @@ void complete_iocp_recvfrom(
   {
     ec = asio::error::connection_refused;
   }
+  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
+  {
+    ec.assign(0, ec.category());
+  }
 }
 
 #else // defined(ASIO_HAS_IOCP)
@@ -1079,7 +1089,7 @@ size_t sync_recvmsg(socket_type s, state_type state,
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
+    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
@@ -1102,6 +1112,10 @@ void complete_iocp_recvmsg(
   {
     ec = asio::error::connection_refused;
   }
+  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
+  {
+    ec.assign(0, ec.category());
+  }
 }
 
 #else // defined(ASIO_HAS_IOCP)
@@ -1206,7 +1220,7 @@ size_t sync_send(socket_type s, state_type state, const buf* bufs,
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, ec) < 0)
+    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
       return 0;
   }
 }
@@ -1330,7 +1344,7 @@ size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, ec) < 0)
+    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
       return 0;
   }
 }
@@ -1633,7 +1647,8 @@ int getpeername(socket_type s, socket_addr_type* addr,
     return socket_error_retval;
   }
 
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+#if defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP) \
+  || defined(__CYGWIN__)
   if (cached)
   {
     // Check if socket is still connected.
@@ -1654,9 +1669,11 @@ int getpeername(socket_type s, socket_addr_type* addr,
     ec = asio::error_code();
     return 0;
   }
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+#else // defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP)
+      // || defined(__CYGWIN__)
   (void)cached;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP)
+       // || defined(__CYGWIN__)
 
   clear_last_error();
   int result = error_wrapper(call_getpeername(
@@ -1781,7 +1798,8 @@ int select(int nfds, fd_set* readfds, fd_set* writefds,
 #endif
 }
 
-int poll_read(socket_type s, state_type state, asio::error_code& ec)
+int poll_read(socket_type s, state_type state,
+    int msec, asio::error_code& ec)
 {
   if (s == invalid_socket)
   {
@@ -1795,10 +1813,22 @@ int poll_read(socket_type s, state_type state, asio::error_code& ec)
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(s, &fds);
-  timeval zero_timeout;
-  zero_timeout.tv_sec = 0;
-  zero_timeout.tv_usec = 0;
-  timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
+  timeval timeout_obj;
+  timeval* timeout;
+  if (state & user_set_non_blocking)
+  {
+    timeout_obj.tv_sec = 0;
+    timeout_obj.tv_usec = 0;
+    timeout = &timeout_obj;
+  }
+  else if (msec >= 0)
+  {
+    timeout_obj.tv_sec = msec / 1000;
+    timeout_obj.tv_usec = (msec % 1000) * 1000;
+    timeout = &timeout_obj;
+  }
+  else
+    timeout = 0;
   clear_last_error();
   int result = error_wrapper(::select(s + 1, &fds, 0, 0, timeout), ec);
 #else // defined(ASIO_WINDOWS)
@@ -1808,7 +1838,7 @@ int poll_read(socket_type s, state_type state, asio::error_code& ec)
   fds.fd = s;
   fds.events = POLLIN;
   fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : -1;
+  int timeout = (state & user_set_non_blocking) ? 0 : msec;
   clear_last_error();
   int result = error_wrapper(::poll(&fds, 1, timeout), ec);
 #endif // defined(ASIO_WINDOWS)
@@ -1822,7 +1852,8 @@ int poll_read(socket_type s, state_type state, asio::error_code& ec)
   return result;
 }
 
-int poll_write(socket_type s, state_type state, asio::error_code& ec)
+int poll_write(socket_type s, state_type state,
+    int msec, asio::error_code& ec)
 {
   if (s == invalid_socket)
   {
@@ -1836,10 +1867,22 @@ int poll_write(socket_type s, state_type state, asio::error_code& ec)
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(s, &fds);
-  timeval zero_timeout;
-  zero_timeout.tv_sec = 0;
-  zero_timeout.tv_usec = 0;
-  timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
+  timeval timeout_obj;
+  timeval* timeout;
+  if (state & user_set_non_blocking)
+  {
+    timeout_obj.tv_sec = 0;
+    timeout_obj.tv_usec = 0;
+    timeout = &timeout_obj;
+  }
+  else if (msec >= 0)
+  {
+    timeout_obj.tv_sec = msec / 1000;
+    timeout_obj.tv_usec = (msec % 1000) * 1000;
+    timeout = &timeout_obj;
+  }
+  else
+    timeout = 0;
   clear_last_error();
   int result = error_wrapper(::select(s + 1, 0, &fds, 0, timeout), ec);
 #else // defined(ASIO_WINDOWS)
@@ -1849,7 +1892,61 @@ int poll_write(socket_type s, state_type state, asio::error_code& ec)
   fds.fd = s;
   fds.events = POLLOUT;
   fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : -1;
+  int timeout = (state & user_set_non_blocking) ? 0 : msec;
+  clear_last_error();
+  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
+#endif // defined(ASIO_WINDOWS)
+       // || defined(__CYGWIN__)
+       // || defined(__SYMBIAN32__)
+  if (result == 0)
+    ec = (state & user_set_non_blocking)
+      ? asio::error::would_block : asio::error_code();
+  else if (result > 0)
+    ec = asio::error_code();
+  return result;
+}
+
+int poll_error(socket_type s, state_type state,
+    int msec, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+#if defined(ASIO_WINDOWS) \
+  || defined(__CYGWIN__) \
+  || defined(__SYMBIAN32__)
+  fd_set fds;
+  FD_ZERO(&fds);
+  FD_SET(s, &fds);
+  timeval timeout_obj;
+  timeval* timeout;
+  if (state & user_set_non_blocking)
+  {
+    timeout_obj.tv_sec = 0;
+    timeout_obj.tv_usec = 0;
+    timeout = &timeout_obj;
+  }
+  else if (msec >= 0)
+  {
+    timeout_obj.tv_sec = msec / 1000;
+    timeout_obj.tv_usec = (msec % 1000) * 1000;
+    timeout = &timeout_obj;
+  }
+  else
+    timeout = 0;
+  clear_last_error();
+  int result = error_wrapper(::select(s + 1, 0, 0, &fds, timeout), ec);
+#else // defined(ASIO_WINDOWS)
+      // || defined(__CYGWIN__)
+      // || defined(__SYMBIAN32__)
+  pollfd fds;
+  fds.fd = s;
+  fds.events = POLLPRI | POLLERR | POLLHUP;
+  fds.revents = 0;
+  int timeout = (state & user_set_non_blocking) ? 0 : msec;
   clear_last_error();
   int result = error_wrapper(::poll(&fds, 1, timeout), ec);
 #endif // defined(ASIO_WINDOWS)
@@ -1863,7 +1960,7 @@ int poll_write(socket_type s, state_type state, asio::error_code& ec)
   return result;
 }
 
-int poll_connect(socket_type s, asio::error_code& ec)
+int poll_connect(socket_type s, int msec, asio::error_code& ec)
 {
   if (s == invalid_socket)
   {
@@ -1880,9 +1977,19 @@ int poll_connect(socket_type s, asio::error_code& ec)
   fd_set except_fds;
   FD_ZERO(&except_fds);
   FD_SET(s, &except_fds);
+  timeval timeout_obj;
+  timeval* timeout;
+  if (msec >= 0)
+  {
+    timeout_obj.tv_sec = msec / 1000;
+    timeout_obj.tv_usec = (msec % 1000) * 1000;
+    timeout = &timeout_obj;
+  }
+  else
+    timeout = 0;
   clear_last_error();
   int result = error_wrapper(::select(
-        s + 1, 0, &write_fds, &except_fds, 0), ec);
+        s + 1, 0, &write_fds, &except_fds, timeout), ec);
   if (result >= 0)
     ec = asio::error_code();
   return result;
@@ -1894,7 +2001,7 @@ int poll_connect(socket_type s, asio::error_code& ec)
   fds.events = POLLOUT;
   fds.revents = 0;
   clear_last_error();
-  int result = error_wrapper(::poll(&fds, 1, -1), ec);
+  int result = error_wrapper(::poll(&fds, 1, msec), ec);
   if (result >= 0)
     ec = asio::error_code();
   return result;
@@ -2580,7 +2687,8 @@ inline void gai_strcpy(char* target, const char* source, std::size_t max_size)
   strcpy_s(target, max_size, source);
 #else // defined(ASIO_HAS_SECURE_RTL)
   *target = 0;
-  strncat(target, source, max_size);
+  if (max_size > 0)
+    strncat(target, source, max_size - 1);
 #endif // defined(ASIO_HAS_SECURE_RTL)
 }
 
@@ -3233,6 +3341,37 @@ asio::error_code getaddrinfo(const char* host,
   return ec = translate_addrinfo_error(error);
 #else
   int error = ::getaddrinfo(host, service, &hints, result);
+#if defined(__MACH__) && defined(__APPLE__)
+  using namespace std; // For isdigit and atoi.
+  if (error == 0 && service && isdigit(static_cast<unsigned char>(service[0])))
+  {
+    u_short_type port = host_to_network_short(atoi(service));
+    for (addrinfo_type* ai = *result; ai; ai = ai->ai_next)
+    {
+      switch (ai->ai_family)
+      {
+      case ASIO_OS_DEF(AF_INET):
+        {
+          sockaddr_in4_type* sinptr =
+            reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
+          if (sinptr->sin_port == 0)
+            sinptr->sin_port = port;
+          break;
+        }
+      case ASIO_OS_DEF(AF_INET6):
+        {
+          sockaddr_in6_type* sin6ptr =
+            reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
+          if (sin6ptr->sin6_port == 0)
+            sin6ptr->sin6_port = port;
+          break;
+        }
+      default:
+        break;
+      }
+    }
+  }
+#endif
   return ec = translate_addrinfo_error(error);
 #endif
 }
@@ -3310,7 +3449,6 @@ asio::error_code getnameinfo(const socket_addr_type* addr,
   using namespace std; // For memcpy.
   sockaddr_storage_type tmp_addr;
   memcpy(&tmp_addr, addr, addrlen);
-  tmp_addr.ss_len = addrlen;
   addr = reinterpret_cast<socket_addr_type*>(&tmp_addr);
   clear_last_error();
   return getnameinfo_emulation(addr, addrlen,
diff --git a/extern/include/asio/detail/impl/socket_select_interrupter.ipp b/extern/include/asio/detail/impl/socket_select_interrupter.ipp
index 21c0fbce..052f2a76 100644
--- a/extern/include/asio/detail/impl/socket_select_interrupter.ipp
+++ b/extern/include/asio/detail/impl/socket_select_interrupter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/socket_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -71,7 +71,8 @@ void socket_select_interrupter::open_descriptors()
   // Some broken firewalls on Windows will intermittently cause getsockname to
   // return 0.0.0.0 when the socket is actually bound to 127.0.0.1. We
   // explicitly specify the target address here to work around this problem.
-  addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
+  if (addr.sin_addr.s_addr == socket_ops::host_to_network_long(INADDR_ANY))
+    addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
 
   if (socket_ops::listen(acceptor.get(),
         SOMAXCONN, ec) == socket_error_retval)
diff --git a/extern/include/asio/detail/impl/strand_executor_service.hpp b/extern/include/asio/detail/impl/strand_executor_service.hpp
new file mode 100644
index 00000000..0e18ca05
--- /dev/null
+++ b/extern/include/asio/detail/impl/strand_executor_service.hpp
@@ -0,0 +1,179 @@
+//
+// detail/impl/strand_executor_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP
+#define ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/call_stack.hpp"
+#include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/recycling_allocator.hpp"
+#include "asio/executor_work_guard.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Executor>
+class strand_executor_service::invoker
+{
+public:
+  invoker(const implementation_type& impl, Executor& ex)
+    : impl_(impl),
+      work_(ex)
+  {
+  }
+
+  invoker(const invoker& other)
+    : impl_(other.impl_),
+      work_(other.work_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  invoker(invoker&& other)
+    : impl_(ASIO_MOVE_CAST(implementation_type)(other.impl_)),
+      work_(ASIO_MOVE_CAST(executor_work_guard<Executor>)(other.work_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  struct on_invoker_exit
+  {
+    invoker* this_;
+
+    ~on_invoker_exit()
+    {
+      this_->impl_->mutex_->lock();
+      this_->impl_->ready_queue_.push(this_->impl_->waiting_queue_);
+      bool more_handlers = this_->impl_->locked_ =
+        !this_->impl_->ready_queue_.empty();
+      this_->impl_->mutex_->unlock();
+
+      if (more_handlers)
+      {
+        Executor ex(this_->work_.get_executor());
+        recycling_allocator<void> allocator;
+        ex.post(ASIO_MOVE_CAST(invoker)(*this_), allocator);
+      }
+    }
+  };
+
+  void operator()()
+  {
+    // Indicate that this strand is executing on the current thread.
+    call_stack<strand_impl>::context ctx(impl_.get());
+
+    // Ensure the next handler, if any, is scheduled on block exit.
+    on_invoker_exit on_exit = { this };
+    (void)on_exit;
+
+    // Run all ready handlers. No lock is required since the ready queue is
+    // accessed only within the strand.
+    asio::error_code ec;
+    while (scheduler_operation* o = impl_->ready_queue_.front())
+    {
+      impl_->ready_queue_.pop();
+      o->complete(impl_.get(), ec, 0);
+    }
+  }
+
+private:
+  implementation_type impl_;
+  executor_work_guard<Executor> work_;
+};
+
+template <typename Executor, typename Function, typename Allocator>
+void strand_executor_service::dispatch(const implementation_type& impl,
+    Executor& ex, ASIO_MOVE_ARG(Function) function, const Allocator& a)
+{
+  typedef typename decay<Function>::type function_type;
+
+  // If we are already in the strand then the function can run immediately.
+  if (call_stack<strand_impl>::contains(impl.get()))
+  {
+    // Make a local, non-const copy of the function.
+    function_type tmp(ASIO_MOVE_CAST(Function)(function));
+
+    fenced_block b(fenced_block::full);
+    asio_handler_invoke_helpers::invoke(tmp, tmp);
+    return;
+  }
+
+  // Allocate and construct an operation to wrap the function.
+  typedef executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(function), a);
+
+  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
+        "strand_executor", impl.get(), 0, "dispatch"));
+
+  // Add the function to the strand and schedule the strand if required.
+  bool first = enqueue(impl, p.p);
+  p.v = p.p = 0;
+  if (first)
+    ex.dispatch(invoker<Executor>(impl, ex), a);
+}
+
+// Request invocation of the given function and return immediately.
+template <typename Executor, typename Function, typename Allocator>
+void strand_executor_service::post(const implementation_type& impl,
+    Executor& ex, ASIO_MOVE_ARG(Function) function, const Allocator& a)
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Allocate and construct an operation to wrap the function.
+  typedef executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(function), a);
+
+  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
+        "strand_executor", impl.get(), 0, "post"));
+
+  // Add the function to the strand and schedule the strand if required.
+  bool first = enqueue(impl, p.p);
+  p.v = p.p = 0;
+  if (first)
+    ex.post(invoker<Executor>(impl, ex), a);
+}
+
+// Request invocation of the given function and return immediately.
+template <typename Executor, typename Function, typename Allocator>
+void strand_executor_service::defer(const implementation_type& impl,
+    Executor& ex, ASIO_MOVE_ARG(Function) function, const Allocator& a)
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Allocate and construct an operation to wrap the function.
+  typedef executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(function), a);
+
+  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
+        "strand_executor", impl.get(), 0, "defer"));
+
+  // Add the function to the strand and schedule the strand if required.
+  bool first = enqueue(impl, p.p);
+  p.v = p.p = 0;
+  if (first)
+    ex.defer(invoker<Executor>(impl, ex), a);
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP
diff --git a/extern/include/asio/detail/impl/strand_executor_service.ipp b/extern/include/asio/detail/impl/strand_executor_service.ipp
new file mode 100644
index 00000000..365652ec
--- /dev/null
+++ b/extern/include/asio/detail/impl/strand_executor_service.ipp
@@ -0,0 +1,134 @@
+//
+// detail/impl/strand_executor_service.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP
+#define ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/strand_executor_service.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+strand_executor_service::strand_executor_service(execution_context& ctx)
+  : execution_context_service_base<strand_executor_service>(ctx),
+    mutex_(),
+    salt_(0),
+    impl_list_(0)
+{
+}
+
+void strand_executor_service::shutdown()
+{
+  op_queue<scheduler_operation> ops;
+
+  asio::detail::mutex::scoped_lock lock(mutex_);
+
+  strand_impl* impl = impl_list_;
+  while (impl)
+  {
+    impl->mutex_->lock();
+    impl->shutdown_ = true;
+    ops.push(impl->waiting_queue_);
+    ops.push(impl->ready_queue_);
+    impl->mutex_->unlock();
+    impl = impl->next_;
+  }
+}
+
+strand_executor_service::implementation_type
+strand_executor_service::create_implementation()
+{
+  implementation_type new_impl(new strand_impl);
+  new_impl->locked_ = false;
+  new_impl->shutdown_ = false;
+
+  asio::detail::mutex::scoped_lock lock(mutex_);
+
+  // Select a mutex from the pool of shared mutexes.
+  std::size_t salt = salt_++;
+  std::size_t mutex_index = reinterpret_cast<std::size_t>(new_impl.get());
+  mutex_index += (reinterpret_cast<std::size_t>(new_impl.get()) >> 3);
+  mutex_index ^= salt + 0x9e3779b9 + (mutex_index << 6) + (mutex_index >> 2);
+  mutex_index = mutex_index % num_mutexes;
+  if (!mutexes_[mutex_index].get())
+    mutexes_[mutex_index].reset(new mutex);
+  new_impl->mutex_ = mutexes_[mutex_index].get();
+
+  // Insert implementation into linked list of all implementations.
+  new_impl->next_ = impl_list_;
+  new_impl->prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = new_impl.get();
+  impl_list_ = new_impl.get();
+  new_impl->service_ = this;
+
+  return new_impl;
+}
+
+strand_executor_service::strand_impl::~strand_impl()
+{
+  asio::detail::mutex::scoped_lock lock(service_->mutex_);
+
+  // Remove implementation from linked list of all implementations.
+  if (service_->impl_list_ == this)
+    service_->impl_list_ = next_;
+  if (prev_)
+    prev_->next_ = next_;
+  if (next_)
+    next_->prev_= prev_;
+}
+
+bool strand_executor_service::enqueue(const implementation_type& impl,
+    scheduler_operation* op)
+{
+  impl->mutex_->lock();
+  if (impl->shutdown_)
+  {
+    impl->mutex_->unlock();
+    op->destroy();
+    return false;
+  }
+  else if (impl->locked_)
+  {
+    // Some other function already holds the strand lock. Enqueue for later.
+    impl->waiting_queue_.push(op);
+    impl->mutex_->unlock();
+    return false;
+  }
+  else
+  {
+    // The function is acquiring the strand lock and so is responsible for
+    // scheduling the strand.
+    impl->locked_ = true;
+    impl->mutex_->unlock();
+    impl->ready_queue_.push(op);
+    return true;
+  }
+}
+
+bool strand_executor_service::running_in_this_thread(
+    const implementation_type& impl)
+{
+  return !!call_stack<strand_impl>::contains(impl.get());
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP
diff --git a/extern/include/asio/detail/impl/strand_service.hpp b/extern/include/asio/detail/impl/strand_service.hpp
index b34b7764..da5b7169 100644
--- a/extern/include/asio/detail/impl/strand_service.hpp
+++ b/extern/include/asio/detail/impl/strand_service.hpp
@@ -2,7 +2,7 @@
 // detail/impl/strand_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,12 +15,12 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/call_stack.hpp"
 #include "asio/detail/completion_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -35,7 +35,7 @@ inline strand_service::strand_impl::strand_impl()
 
 struct strand_service::on_dispatch_exit
 {
-  io_service_impl* io_service_;
+  io_context_impl* io_context_;
   strand_impl* impl_;
 
   ~on_dispatch_exit()
@@ -46,7 +46,7 @@ struct strand_service::on_dispatch_exit
     impl_->mutex_.unlock();
 
     if (more_handlers)
-      io_service_->post_immediate_completion(impl_, false);
+      io_context_->post_immediate_completion(impl_, false);
   }
 };
 
@@ -65,11 +65,11 @@ void strand_service::dispatch(strand_service::implementation_type& impl,
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
   typename op::ptr p = { asio::detail::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
+    op::ptr::allocate(handler), 0 };
   p.p = new (p.v) op(handler);
 
-  ASIO_HANDLER_CREATION((p.p, "strand", impl, "dispatch"));
+  ASIO_HANDLER_CREATION((this->context(),
+        *p.p, "strand", impl, 0, "dispatch"));
 
   bool dispatch_immediately = do_dispatch(impl, p.p);
   operation* o = p.p;
@@ -81,15 +81,15 @@ void strand_service::dispatch(strand_service::implementation_type& impl,
     call_stack<strand_impl>::context ctx(impl);
 
     // Ensure the next handler, if any, is scheduled on block exit.
-    on_dispatch_exit on_exit = { &io_service_, impl };
+    on_dispatch_exit on_exit = { &io_context_, impl };
     (void)on_exit;
 
     completion_handler<Handler>::do_complete(
-        &io_service_, o, asio::error_code(), 0);
+        &io_context_, o, asio::error_code(), 0);
   }
 }
 
-// Request the io_service to invoke the given handler and return immediately.
+// Request the io_context to invoke the given handler and return immediately.
 template <typename Handler>
 void strand_service::post(strand_service::implementation_type& impl,
     Handler& handler)
@@ -100,11 +100,11 @@ void strand_service::post(strand_service::implementation_type& impl,
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
   typename op::ptr p = { asio::detail::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
+    op::ptr::allocate(handler), 0 };
   p.p = new (p.v) op(handler);
 
-  ASIO_HANDLER_CREATION((p.p, "strand", impl, "post"));
+  ASIO_HANDLER_CREATION((this->context(),
+        *p.p, "strand", impl, 0, "post"));
 
   do_post(impl, p.p, is_continuation);
   p.v = p.p = 0;
diff --git a/extern/include/asio/detail/impl/strand_service.ipp b/extern/include/asio/detail/impl/strand_service.ipp
index e99da033..cbaf25b3 100644
--- a/extern/include/asio/detail/impl/strand_service.ipp
+++ b/extern/include/asio/detail/impl/strand_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/strand_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -26,7 +26,7 @@ namespace detail {
 
 struct strand_service::on_do_complete_exit
 {
-  io_service_impl* owner_;
+  io_context_impl* owner_;
   strand_impl* impl_;
 
   ~on_do_complete_exit()
@@ -41,15 +41,15 @@ struct strand_service::on_do_complete_exit
   }
 };
 
-strand_service::strand_service(asio::io_service& io_service)
-  : asio::detail::service_base<strand_service>(io_service),
-    io_service_(asio::use_service<io_service_impl>(io_service)),
+strand_service::strand_service(asio::io_context& io_context)
+  : asio::detail::service_base<strand_service>(io_context),
+    io_context_(asio::use_service<io_context_impl>(io_context)),
     mutex_(),
     salt_(0)
 {
 }
 
-void strand_service::shutdown_service()
+void strand_service::shutdown()
 {
   op_queue<operation> ops;
 
@@ -92,9 +92,9 @@ bool strand_service::running_in_this_thread(
 
 bool strand_service::do_dispatch(implementation_type& impl, operation* op)
 {
-  // If we are running inside the io_service, and no other handler already
+  // If we are running inside the io_context, and no other handler already
   // holds the strand lock, then the handler can run immediately.
-  bool can_dispatch = io_service_.can_dispatch();
+  bool can_dispatch = io_context_.can_dispatch();
   impl->mutex_.lock();
   if (can_dispatch && !impl->locked_)
   {
@@ -117,7 +117,7 @@ bool strand_service::do_dispatch(implementation_type& impl, operation* op)
     impl->locked_ = true;
     impl->mutex_.unlock();
     impl->ready_queue_.push(op);
-    io_service_.post_immediate_completion(impl, false);
+    io_context_.post_immediate_completion(impl, false);
   }
 
   return false;
@@ -140,11 +140,11 @@ void strand_service::do_post(implementation_type& impl,
     impl->locked_ = true;
     impl->mutex_.unlock();
     impl->ready_queue_.push(op);
-    io_service_.post_immediate_completion(impl, is_continuation);
+    io_context_.post_immediate_completion(impl, is_continuation);
   }
 }
 
-void strand_service::do_complete(io_service_impl* owner, operation* base,
+void strand_service::do_complete(void* owner, operation* base,
     const asio::error_code& ec, std::size_t /*bytes_transferred*/)
 {
   if (owner)
@@ -155,15 +155,16 @@ void strand_service::do_complete(io_service_impl* owner, operation* base,
     call_stack<strand_impl>::context ctx(impl);
 
     // Ensure the next handler, if any, is scheduled on block exit.
-    on_do_complete_exit on_exit = { owner, impl };
-    (void)on_exit;
+    on_do_complete_exit on_exit;
+    on_exit.owner_ = static_cast<io_context_impl*>(owner);
+    on_exit.impl_ = impl;
 
     // Run all ready handlers. No lock is required since the ready queue is
     // accessed only within the strand.
     while (operation* o = impl->ready_queue_.front())
     {
       impl->ready_queue_.pop();
-      o->complete(*owner, ec, 0);
+      o->complete(owner, ec, 0);
     }
   }
 }
diff --git a/extern/include/asio/detail/impl/task_io_service.hpp b/extern/include/asio/detail/impl/task_io_service.hpp
deleted file mode 100644
index cef9371d..00000000
--- a/extern/include/asio/detail/impl/task_io_service.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//
-// detail/impl/task_io_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/addressof.hpp"
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler>
-void task_io_service::dispatch(Handler& handler)
-{
-  if (thread_call_stack::contains(this))
-  {
-    fenced_block b(fenced_block::full);
-    asio_handler_invoke_helpers::invoke(handler, handler);
-  }
-  else
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef completion_handler<Handler> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(handler);
-
-    ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch"));
-
-    do_dispatch(p.p);
-    p.v = p.p = 0;
-  }
-}
-
-template <typename Handler>
-void task_io_service::post(Handler& handler)
-{
-  bool is_continuation =
-    asio_handler_cont_helpers::is_continuation(handler);
-
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
-  typename op::ptr p = { asio::detail::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
-  p.p = new (p.v) op(handler);
-
-  ASIO_HANDLER_CREATION((p.p, "io_service", this, "post"));
-
-  post_immediate_completion(p.p, is_continuation);
-  p.v = p.p = 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
diff --git a/extern/include/asio/detail/impl/throw_error.ipp b/extern/include/asio/detail/impl/throw_error.ipp
index 0e327d0e..a540cd20 100644
--- a/extern/include/asio/detail/impl/throw_error.ipp
+++ b/extern/include/asio/detail/impl/throw_error.ipp
@@ -2,7 +2,7 @@
 // detail/impl/throw_error.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/impl/timer_queue_ptime.ipp b/extern/include/asio/detail/impl/timer_queue_ptime.ipp
index 3a396eec..742837f8 100644
--- a/extern/include/asio/detail/impl/timer_queue_ptime.ipp
+++ b/extern/include/asio/detail/impl/timer_queue_ptime.ipp
@@ -2,7 +2,7 @@
 // detail/impl/timer_queue_ptime.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,12 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_BOOST_DATE_TIME)
+
 #include "asio/detail/timer_queue_ptime.hpp"
 
 #include "asio/detail/push_options.hpp"
 
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-
 namespace asio {
 namespace detail {
 
@@ -74,11 +75,17 @@ std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
   return impl_.cancel_timer(timer, ops, max_cancelled);
 }
 
+void timer_queue<time_traits<boost::posix_time::ptime> >::move_timer(
+    per_timer_data& target, per_timer_data& source)
+{
+  impl_.move_timer(target, source);
+}
+
 } // namespace detail
 } // namespace asio
 
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+
 #endif // ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
diff --git a/extern/include/asio/detail/impl/timer_queue_set.ipp b/extern/include/asio/detail/impl/timer_queue_set.ipp
index b76e238d..b5165488 100644
--- a/extern/include/asio/detail/impl/timer_queue_set.ipp
+++ b/extern/include/asio/detail/impl/timer_queue_set.ipp
@@ -2,7 +2,7 @@
 // detail/impl/timer_queue_set.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/impl/win_event.ipp b/extern/include/asio/detail/impl/win_event.ipp
index 38bfe52b..6f746499 100644
--- a/extern/include/asio/detail/impl/win_event.ipp
+++ b/extern/include/asio/detail/impl/win_event.ipp
@@ -2,7 +2,7 @@
 // detail/win_event.ipp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,7 +31,12 @@ namespace detail {
 win_event::win_event()
   : state_(0)
 {
-  events_[0] = ::CreateEvent(0, true, false, 0);
+#if defined(ASIO_WINDOWS_APP)
+  events_[0] = ::CreateEventExW(0, 0,
+      CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
+#else // defined(ASIO_WINDOWS_APP)
+  events_[0] = ::CreateEventW(0, true, false, 0);
+#endif // defined(ASIO_WINDOWS_APP)
   if (!events_[0])
   {
     DWORD last_error = ::GetLastError();
@@ -40,7 +45,11 @@ win_event::win_event()
     asio::detail::throw_error(ec, "event");
   }
 
-  events_[1] = ::CreateEvent(0, false, false, 0);
+#if defined(ASIO_WINDOWS_APP)
+  events_[1] = ::CreateEventExW(0, 0, 0, EVENT_ALL_ACCESS);
+#else // defined(ASIO_WINDOWS_APP)
+  events_[1] = ::CreateEventW(0, false, false, 0);
+#endif // defined(ASIO_WINDOWS_APP)
   if (!events_[1])
   {
     DWORD last_error = ::GetLastError();
diff --git a/extern/include/asio/detail/impl/win_iocp_handle_service.ipp b/extern/include/asio/detail/impl/win_iocp_handle_service.ipp
index b484f7bc..9cba2b0f 100644
--- a/extern/include/asio/detail/impl/win_iocp_handle_service.ipp
+++ b/extern/include/asio/detail/impl/win_iocp_handle_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_handle_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -39,7 +39,7 @@ public:
     OffsetHigh = 0;
 
     // Create a non-signalled manual-reset event, for GetOverlappedResult.
-    hEvent = ::CreateEvent(0, TRUE, FALSE, 0);
+    hEvent = ::CreateEventW(0, TRUE, FALSE, 0);
     if (hEvent)
     {
       // As documented in GetQueuedCompletionStatus, setting the low order
@@ -66,14 +66,15 @@ public:
 };
 
 win_iocp_handle_service::win_iocp_handle_service(
-    asio::io_service& io_service)
-  : iocp_service_(asio::use_service<win_iocp_io_service>(io_service)),
+    asio::io_context& io_context)
+  : service_base<win_iocp_handle_service>(io_context),
+    iocp_service_(asio::use_service<win_iocp_io_context>(io_context)),
     mutex_(),
     impl_list_(0)
 {
 }
 
-void win_iocp_handle_service::shutdown_service()
+void win_iocp_handle_service::shutdown()
 {
   // Close all implementations, causing all operations to complete.
   asio::detail::mutex::scoped_lock lock(mutex_);
@@ -199,7 +200,8 @@ asio::error_code win_iocp_handle_service::close(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("handle", &impl, "close"));
+    ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle",
+          &impl, reinterpret_cast<uintmax_t>(impl.handle_), "close"));
 
     if (!::CloseHandle(impl.handle_))
     {
@@ -233,7 +235,8 @@ asio::error_code win_iocp_handle_service::cancel(
     return ec;
   }
 
-  ASIO_HANDLER_OPERATION(("handle", &impl, "cancel"));
+  ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle",
+        &impl, reinterpret_cast<uintmax_t>(impl.handle_), "cancel"));
 
   if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
         ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
@@ -303,7 +306,7 @@ size_t win_iocp_handle_service::do_write(
   }
 
   // A request to write 0 bytes on a handle is a no-op.
-  if (asio::buffer_size(buffer) == 0)
+  if (buffer.size() == 0)
   {
     ec = asio::error_code();
     return 0;
@@ -318,9 +321,8 @@ size_t win_iocp_handle_service::do_write(
   // Write the data. 
   overlapped.Offset = offset & 0xFFFFFFFF;
   overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-  BOOL ok = ::WriteFile(impl.handle_,
-      asio::buffer_cast<LPCVOID>(buffer),
-      static_cast<DWORD>(asio::buffer_size(buffer)), 0, &overlapped);
+  BOOL ok = ::WriteFile(impl.handle_, buffer.data(),
+      static_cast<DWORD>(buffer.size()), 0, &overlapped);
   if (!ok) 
   {
     DWORD last_error = ::GetLastError();
@@ -359,7 +361,7 @@ void win_iocp_handle_service::start_write_op(
   {
     iocp_service_.on_completion(op, asio::error::bad_descriptor);
   }
-  else if (asio::buffer_size(buffer) == 0)
+  else if (buffer.size() == 0)
   {
     // A request to write 0 bytes on a handle is a no-op.
     iocp_service_.on_completion(op);
@@ -369,9 +371,8 @@ void win_iocp_handle_service::start_write_op(
     DWORD bytes_transferred = 0;
     op->Offset = offset & 0xFFFFFFFF;
     op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-    BOOL ok = ::WriteFile(impl.handle_,
-        asio::buffer_cast<LPCVOID>(buffer),
-        static_cast<DWORD>(asio::buffer_size(buffer)),
+    BOOL ok = ::WriteFile(impl.handle_, buffer.data(),
+        static_cast<DWORD>(buffer.size()),
         &bytes_transferred, op);
     DWORD last_error = ::GetLastError();
     if (!ok && last_error != ERROR_IO_PENDING
@@ -397,7 +398,7 @@ size_t win_iocp_handle_service::do_read(
   }
   
   // A request to read 0 bytes on a stream handle is a no-op.
-  if (asio::buffer_size(buffer) == 0)
+  if (buffer.size() == 0)
   {
     ec = asio::error_code();
     return 0;
@@ -412,9 +413,8 @@ size_t win_iocp_handle_service::do_read(
   // Read some data.
   overlapped.Offset = offset & 0xFFFFFFFF;
   overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-  BOOL ok = ::ReadFile(impl.handle_,
-      asio::buffer_cast<LPVOID>(buffer),
-      static_cast<DWORD>(asio::buffer_size(buffer)), 0, &overlapped);
+  BOOL ok = ::ReadFile(impl.handle_, buffer.data(),
+      static_cast<DWORD>(buffer.size()), 0, &overlapped);
   if (!ok) 
   {
     DWORD last_error = ::GetLastError();
@@ -467,7 +467,7 @@ void win_iocp_handle_service::start_read_op(
   {
     iocp_service_.on_completion(op, asio::error::bad_descriptor);
   }
-  else if (asio::buffer_size(buffer) == 0)
+  else if (buffer.size() == 0)
   {
     // A request to read 0 bytes on a handle is a no-op.
     iocp_service_.on_completion(op);
@@ -477,9 +477,8 @@ void win_iocp_handle_service::start_read_op(
     DWORD bytes_transferred = 0;
     op->Offset = offset & 0xFFFFFFFF;
     op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-    BOOL ok = ::ReadFile(impl.handle_,
-        asio::buffer_cast<LPVOID>(buffer),
-        static_cast<DWORD>(asio::buffer_size(buffer)),
+    BOOL ok = ::ReadFile(impl.handle_, buffer.data(),
+        static_cast<DWORD>(buffer.size()),
         &bytes_transferred, op);
     DWORD last_error = ::GetLastError();
     if (!ok && last_error != ERROR_IO_PENDING
@@ -507,7 +506,8 @@ void win_iocp_handle_service::close_for_destruction(implementation_type& impl)
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("handle", &impl, "close"));
+    ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle",
+          &impl, reinterpret_cast<uintmax_t>(impl.handle_), "close"));
 
     ::CloseHandle(impl.handle_);
     impl.handle_ = INVALID_HANDLE_VALUE;
diff --git a/extern/include/asio/detail/impl/win_iocp_io_service.hpp b/extern/include/asio/detail/impl/win_iocp_io_context.hpp
similarity index 54%
rename from extern/include/asio/detail/impl/win_iocp_io_service.hpp
rename to extern/include/asio/detail/impl/win_iocp_io_context.hpp
index faa221aa..44887d7c 100644
--- a/extern/include/asio/detail/impl/win_iocp_io_service.hpp
+++ b/extern/include/asio/detail/impl/win_iocp_io_context.hpp
@@ -1,15 +1,15 @@
 //
-// detail/impl/win_iocp_io_service.hpp
+// detail/impl/win_iocp_io_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP
+#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP
+#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -19,73 +19,33 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/completion_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-template <typename Handler>
-void win_iocp_io_service::dispatch(Handler& handler)
-{
-  if (thread_call_stack::contains(this))
-  {
-    fenced_block b(fenced_block::full);
-    asio_handler_invoke_helpers::invoke(handler, handler);
-  }
-  else
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef completion_handler<Handler> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(handler);
-
-    ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch"));
-
-    post_immediate_completion(p.p, false);
-    p.v = p.p = 0;
-  }
-}
-
-template <typename Handler>
-void win_iocp_io_service::post(Handler& handler)
-{
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
-  typename op::ptr p = { asio::detail::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
-  p.p = new (p.v) op(handler);
-
-  ASIO_HANDLER_CREATION((p.p, "io_service", this, "post"));
-
-  post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-
 template <typename Time_Traits>
-void win_iocp_io_service::add_timer_queue(
+void win_iocp_io_context::add_timer_queue(
     timer_queue<Time_Traits>& queue)
 {
   do_add_timer_queue(queue);
 }
 
 template <typename Time_Traits>
-void win_iocp_io_service::remove_timer_queue(
+void win_iocp_io_context::remove_timer_queue(
     timer_queue<Time_Traits>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
 template <typename Time_Traits>
-void win_iocp_io_service::schedule_timer(timer_queue<Time_Traits>& queue,
+void win_iocp_io_context::schedule_timer(timer_queue<Time_Traits>& queue,
     const typename Time_Traits::time_type& time,
     typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
 {
@@ -105,7 +65,7 @@ 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,
+std::size_t win_iocp_io_context::cancel_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& timer,
     std::size_t max_cancelled)
 {
@@ -120,6 +80,19 @@ std::size_t win_iocp_io_service::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
+template <typename Time_Traits>
+void win_iocp_io_context::move_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& to,
+    typename timer_queue<Time_Traits>::per_timer_data& from)
+{
+  asio::detail::mutex::scoped_lock lock(dispatch_mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer(to, ops);
+  queue.move_timer(to, from);
+  lock.unlock();
+  post_deferred_completions(ops);
+}
+
 } // namespace detail
 } // namespace asio
 
@@ -127,4 +100,4 @@ std::size_t win_iocp_io_service::cancel_timer(timer_queue<Time_Traits>& queue,
 
 #endif // defined(ASIO_HAS_IOCP)
 
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP
+#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP
diff --git a/extern/include/asio/detail/impl/win_iocp_io_service.ipp b/extern/include/asio/detail/impl/win_iocp_io_context.ipp
similarity index 80%
rename from extern/include/asio/detail/impl/win_iocp_io_service.ipp
rename to extern/include/asio/detail/impl/win_iocp_io_context.ipp
index 40adca03..c371b86b 100644
--- a/extern/include/asio/detail/impl/win_iocp_io_service.ipp
+++ b/extern/include/asio/detail/impl/win_iocp_io_context.ipp
@@ -1,15 +1,15 @@
 //
-// detail/impl/win_iocp_io_service.ipp
+// detail/impl/win_iocp_io_context.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP
+#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP
+#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -20,64 +20,63 @@
 #if defined(ASIO_HAS_IOCP)
 
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
 #include "asio/detail/cstdint.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
 #include "asio/detail/limits.hpp"
 #include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_iocp_io_service.hpp"
+#include "asio/detail/win_iocp_io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-struct win_iocp_io_service::work_finished_on_block_exit
+struct win_iocp_io_context::work_finished_on_block_exit
 {
   ~work_finished_on_block_exit()
   {
-    io_service_->work_finished();
+    io_context_->work_finished();
   }
 
-  win_iocp_io_service* io_service_;
+  win_iocp_io_context* io_context_;
 };
 
-struct win_iocp_io_service::timer_thread_function
+struct win_iocp_io_context::timer_thread_function
 {
   void operator()()
   {
-    while (::InterlockedExchangeAdd(&io_service_->shutdown_, 0) == 0)
+    while (::InterlockedExchangeAdd(&io_context_->shutdown_, 0) == 0)
     {
-      if (::WaitForSingleObject(io_service_->waitable_timer_.handle,
+      if (::WaitForSingleObject(io_context_->waitable_timer_.handle,
             INFINITE) == WAIT_OBJECT_0)
       {
-        ::InterlockedExchange(&io_service_->dispatch_required_, 1);
-        ::PostQueuedCompletionStatus(io_service_->iocp_.handle,
+        ::InterlockedExchange(&io_context_->dispatch_required_, 1);
+        ::PostQueuedCompletionStatus(io_context_->iocp_.handle,
             0, wake_for_dispatch, 0);
       }
     }
   }
 
-  win_iocp_io_service* io_service_;
+  win_iocp_io_context* io_context_;
 };
 
-win_iocp_io_service::win_iocp_io_service(
-    asio::io_service& io_service, size_t concurrency_hint)
-  : asio::detail::service_base<win_iocp_io_service>(io_service),
+win_iocp_io_context::win_iocp_io_context(
+    asio::execution_context& ctx, int concurrency_hint)
+  : execution_context_service_base<win_iocp_io_context>(ctx),
     iocp_(),
     outstanding_work_(0),
     stopped_(0),
     stop_event_posted_(0),
     shutdown_(0),
     gqcs_timeout_(get_gqcs_timeout()),
-    dispatch_required_(0)
+    dispatch_required_(0),
+    concurrency_hint_(concurrency_hint)
 {
   ASIO_HANDLER_TRACKING_INIT;
 
   iocp_.handle = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0,
-      static_cast<DWORD>(concurrency_hint < DWORD(~0)
-        ? concurrency_hint : DWORD(~0)));
+      static_cast<DWORD>(concurrency_hint >= 0 ? concurrency_hint : DWORD(~0)));
   if (!iocp_.handle)
   {
     DWORD last_error = ::GetLastError();
@@ -87,7 +86,7 @@ win_iocp_io_service::win_iocp_io_service(
   }
 }
 
-void win_iocp_io_service::shutdown_service()
+void win_iocp_io_context::shutdown()
 {
   ::InterlockedExchange(&shutdown_, 1);
 
@@ -131,7 +130,7 @@ void win_iocp_io_service::shutdown_service()
     timer_thread_->join();
 }
 
-asio::error_code win_iocp_io_service::register_handle(
+asio::error_code win_iocp_io_context::register_handle(
     HANDLE handle, asio::error_code& ec)
 {
   if (::CreateIoCompletionPort(handle, iocp_.handle, 0, 0) == 0)
@@ -147,7 +146,7 @@ asio::error_code win_iocp_io_service::register_handle(
   return ec;
 }
 
-size_t win_iocp_io_service::run(asio::error_code& ec)
+size_t win_iocp_io_context::run(asio::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
@@ -160,13 +159,13 @@ size_t win_iocp_io_service::run(asio::error_code& ec)
   thread_call_stack::context ctx(this, this_thread);
 
   size_t n = 0;
-  while (do_one(true, ec))
+  while (do_one(INFINITE, ec))
     if (n != (std::numeric_limits<size_t>::max)())
       ++n;
   return n;
 }
 
-size_t win_iocp_io_service::run_one(asio::error_code& ec)
+size_t win_iocp_io_context::run_one(asio::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
@@ -178,10 +177,25 @@ size_t win_iocp_io_service::run_one(asio::error_code& ec)
   win_iocp_thread_info this_thread;
   thread_call_stack::context ctx(this, this_thread);
 
-  return do_one(true, ec);
+  return do_one(INFINITE, ec);
 }
 
-size_t win_iocp_io_service::poll(asio::error_code& ec)
+size_t win_iocp_io_context::wait_one(long usec, asio::error_code& ec)
+{
+  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
+  {
+    stop();
+    ec = asio::error_code();
+    return 0;
+  }
+
+  win_iocp_thread_info this_thread;
+  thread_call_stack::context ctx(this, this_thread);
+
+  return do_one(usec < 0 ? INFINITE : ((usec - 1) / 1000 + 1), ec);
+}
+
+size_t win_iocp_io_context::poll(asio::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
@@ -194,13 +208,13 @@ size_t win_iocp_io_service::poll(asio::error_code& ec)
   thread_call_stack::context ctx(this, this_thread);
 
   size_t n = 0;
-  while (do_one(false, ec))
+  while (do_one(0, ec))
     if (n != (std::numeric_limits<size_t>::max)())
       ++n;
   return n;
 }
 
-size_t win_iocp_io_service::poll_one(asio::error_code& ec)
+size_t win_iocp_io_context::poll_one(asio::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
@@ -212,10 +226,10 @@ size_t win_iocp_io_service::poll_one(asio::error_code& ec)
   win_iocp_thread_info this_thread;
   thread_call_stack::context ctx(this, this_thread);
 
-  return do_one(false, ec);
+  return do_one(0, ec);
 }
 
-void win_iocp_io_service::stop()
+void win_iocp_io_context::stop()
 {
   if (::InterlockedExchange(&stopped_, 1) == 0)
   {
@@ -232,7 +246,7 @@ void win_iocp_io_service::stop()
   }
 }
 
-void win_iocp_io_service::post_deferred_completion(win_iocp_operation* op)
+void win_iocp_io_context::post_deferred_completion(win_iocp_operation* op)
 {
   // Flag the operation as ready.
   op->ready_ = 1;
@@ -247,7 +261,7 @@ void win_iocp_io_service::post_deferred_completion(win_iocp_operation* op)
   }
 }
 
-void win_iocp_io_service::post_deferred_completions(
+void win_iocp_io_context::post_deferred_completions(
     op_queue<win_iocp_operation>& ops)
 {
   while (win_iocp_operation* op = ops.front())
@@ -269,7 +283,7 @@ void win_iocp_io_service::post_deferred_completions(
   }
 }
 
-void win_iocp_io_service::abandon_operations(
+void win_iocp_io_context::abandon_operations(
     op_queue<win_iocp_operation>& ops)
 {
   while (win_iocp_operation* op = ops.front())
@@ -280,7 +294,7 @@ void win_iocp_io_service::abandon_operations(
   }
 }
 
-void win_iocp_io_service::on_pending(win_iocp_operation* op)
+void win_iocp_io_context::on_pending(win_iocp_operation* op)
 {
   if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1)
   {
@@ -296,7 +310,7 @@ void win_iocp_io_service::on_pending(win_iocp_operation* op)
   }
 }
 
-void win_iocp_io_service::on_completion(win_iocp_operation* op,
+void win_iocp_io_context::on_completion(win_iocp_operation* op,
     DWORD last_error, DWORD bytes_transferred)
 {
   // Flag that the operation is ready for invocation.
@@ -319,7 +333,7 @@ void win_iocp_io_service::on_completion(win_iocp_operation* op,
   }
 }
 
-void win_iocp_io_service::on_completion(win_iocp_operation* op,
+void win_iocp_io_context::on_completion(win_iocp_operation* op,
     const asio::error_code& ec, DWORD bytes_transferred)
 {
   // Flag that the operation is ready for invocation.
@@ -341,7 +355,7 @@ void win_iocp_io_service::on_completion(win_iocp_operation* op,
   }
 }
 
-size_t win_iocp_io_service::do_one(bool block, asio::error_code& ec)
+size_t win_iocp_io_context::do_one(DWORD msec, asio::error_code& ec)
 {
   for (;;)
   {
@@ -363,8 +377,9 @@ size_t win_iocp_io_service::do_one(bool block, asio::error_code& ec)
     dword_ptr_t completion_key = 0;
     LPOVERLAPPED overlapped = 0;
     ::SetLastError(0);
-    BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
-        &completion_key, &overlapped, block ? gqcs_timeout_ : 0);
+    BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle,
+        &bytes_transferred, &completion_key, &overlapped,
+        msec < gqcs_timeout_ ? msec : gqcs_timeout_);
     DWORD last_error = ::GetLastError();
 
     if (overlapped)
@@ -401,7 +416,7 @@ size_t win_iocp_io_service::do_one(bool block, asio::error_code& ec)
         work_finished_on_block_exit on_exit = { this };
         (void)on_exit;
 
-        op->complete(*this, result_ec, bytes_transferred);
+        op->complete(this, result_ec, bytes_transferred);
         ec = asio::error_code();
         return 1;
       }
@@ -415,8 +430,9 @@ size_t win_iocp_io_service::do_one(bool block, asio::error_code& ec)
         return 0;
       }
 
-      // If we're not polling we need to keep going until we get a real handler.
-      if (block)
+      // If we're waiting indefinitely we need to keep going until we get a
+      // real handler.
+      if (msec == INFINITE)
         continue;
 
       ec = asio::error_code();
@@ -455,7 +471,7 @@ size_t win_iocp_io_service::do_one(bool block, asio::error_code& ec)
   }
 }
 
-DWORD win_iocp_io_service::get_gqcs_timeout()
+DWORD win_iocp_io_context::get_gqcs_timeout()
 {
   OSVERSIONINFOEX osvi;
   ZeroMemory(&osvi, sizeof(osvi));
@@ -471,7 +487,7 @@ DWORD win_iocp_io_service::get_gqcs_timeout()
   return default_gqcs_timeout;
 }
 
-void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue)
+void win_iocp_io_context::do_add_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(dispatch_mutex_);
 
@@ -502,14 +518,14 @@ void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue)
   }
 }
 
-void win_iocp_io_service::do_remove_timer_queue(timer_queue_base& queue)
+void win_iocp_io_context::do_remove_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(dispatch_mutex_);
 
   timer_queues_.erase(&queue);
 }
 
-void win_iocp_io_service::update_timeout()
+void win_iocp_io_context::update_timeout()
 {
   if (timer_thread_.get())
   {
@@ -535,4 +551,4 @@ void win_iocp_io_service::update_timeout()
 
 #endif // defined(ASIO_HAS_IOCP)
 
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP
+#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP
diff --git a/extern/include/asio/detail/impl/win_iocp_serial_port_service.ipp b/extern/include/asio/detail/impl/win_iocp_serial_port_service.ipp
index 43e46f76..4a9b8cd9 100644
--- a/extern/include/asio/detail/impl/win_iocp_serial_port_service.ipp
+++ b/extern/include/asio/detail/impl/win_iocp_serial_port_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_serial_port_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -29,12 +29,13 @@ namespace asio {
 namespace detail {
 
 win_iocp_serial_port_service::win_iocp_serial_port_service(
-    asio::io_service& io_service)
-  : handle_service_(io_service)
+    asio::io_context& io_context)
+  : service_base<win_iocp_serial_port_service>(io_context),
+    handle_service_(io_context)
 {
 }
 
-void win_iocp_serial_port_service::shutdown_service()
+void win_iocp_serial_port_service::shutdown()
 {
 }
 
diff --git a/extern/include/asio/detail/impl/win_iocp_socket_service_base.ipp b/extern/include/asio/detail/impl/win_iocp_socket_service_base.ipp
index 6794e09f..6c478cd2 100644
--- a/extern/include/asio/detail/impl/win_iocp_socket_service_base.ipp
+++ b/extern/include/asio/detail/impl/win_iocp_socket_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_socket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -27,24 +27,24 @@ namespace asio {
 namespace detail {
 
 win_iocp_socket_service_base::win_iocp_socket_service_base(
-    asio::io_service& io_service)
-  : io_service_(io_service),
-    iocp_service_(use_service<win_iocp_io_service>(io_service)),
+    asio::io_context& io_context)
+  : io_context_(io_context),
+    iocp_service_(use_service<win_iocp_io_context>(io_context)),
     reactor_(0),
     connect_ex_(0),
+    nt_set_info_(0),
     mutex_(),
     impl_list_(0)
 {
 }
 
-void win_iocp_socket_service_base::shutdown_service()
+void win_iocp_socket_service_base::base_shutdown()
 {
   // Close all implementations, causing all operations to complete.
   asio::detail::mutex::scoped_lock lock(mutex_);
   base_implementation_type* impl = impl_list_;
   while (impl)
   {
-    asio::error_code ignored_ec;
     close_for_destruction(*impl);
     impl = impl->next_;
   }
@@ -166,19 +166,27 @@ asio::error_code win_iocp_socket_service_base::close(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+    ASIO_HANDLER_OPERATION((iocp_service_.context(),
+          "socket", &impl, impl.socket_, "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.
-    reactor* r = static_cast<reactor*>(
+    select_reactor* r = static_cast<select_reactor*>(
           interlocked_compare_exchange_pointer(
             reinterpret_cast<void**>(&reactor_), 0, 0));
     if (r)
       r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
-  }
 
-  socket_ops::close(impl.socket_, impl.state_, false, ec);
+    socket_ops::close(impl.socket_, impl.state_, false, ec);
+
+    if (r)
+      r->cleanup_descriptor_data(impl.reactor_data_);
+  }
+  else
+  {
+    ec = asio::error_code();
+  }
 
   impl.socket_ = invalid_socket;
   impl.state_ = 0;
@@ -190,6 +198,39 @@ asio::error_code win_iocp_socket_service_base::close(
   return ec;
 }
 
+socket_type win_iocp_socket_service_base::release(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (!is_open(impl))
+    return invalid_socket;
+
+  cancel(impl, ec);
+  if (ec)
+    return invalid_socket;
+
+  nt_set_info_fn fn = get_nt_set_info();
+  if (fn == 0)
+  {
+    ec = asio::error::operation_not_supported;
+    return invalid_socket;
+  }
+
+  HANDLE sock_as_handle = reinterpret_cast<HANDLE>(impl.socket_);
+  ULONG_PTR iosb[2] = { 0, 0 };
+  void* info[2] = { 0, 0 };
+  if (fn(sock_as_handle, iosb, &info, sizeof(info),
+        61 /* FileReplaceCompletionInformation */))
+  {
+    ec = asio::error::operation_not_supported;
+    return invalid_socket;
+  }
+
+  socket_type tmp = impl.socket_;
+  impl.socket_ = invalid_socket;
+  return tmp;
+}
+
 asio::error_code win_iocp_socket_service_base::cancel(
     win_iocp_socket_service_base::base_implementation_type& impl,
     asio::error_code& ec)
@@ -200,7 +241,8 @@ asio::error_code win_iocp_socket_service_base::cancel(
     return ec;
   }
 
-  ASIO_HANDLER_OPERATION(("socket", &impl, "cancel"));
+  ASIO_HANDLER_OPERATION((iocp_service_.context(),
+        "socket", &impl, impl.socket_, "cancel"));
 
   if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
         ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
@@ -271,7 +313,7 @@ asio::error_code win_iocp_socket_service_base::cancel(
   // Cancel any operations started via the reactor.
   if (!ec)
   {
-    reactor* r = static_cast<reactor*>(
+    select_reactor* r = static_cast<select_reactor*>(
           interlocked_compare_exchange_pointer(
             reinterpret_cast<void**>(&reactor_), 0, 0));
     if (r)
@@ -437,7 +479,7 @@ void win_iocp_socket_service_base::start_null_buffers_receive_op(
   {
     start_reactor_op(impl,
         (flags & socket_base::message_out_of_band)
-          ? reactor::except_op : reactor::read_op,
+          ? select_reactor::except_op : select_reactor::read_op,
         op);
   }
 }
@@ -529,7 +571,7 @@ void win_iocp_socket_service_base::start_reactor_op(
     win_iocp_socket_service_base::base_implementation_type& impl,
     int op_type, reactor_op* op)
 {
-  reactor& r = get_reactor();
+  select_reactor& r = get_reactor();
   update_cancellation_thread_id(impl);
 
   if (is_open(impl))
@@ -590,7 +632,7 @@ void win_iocp_socket_service_base::start_connect_op(
   }
 
   // Otherwise, fall back to a reactor-based implementation.
-  reactor& r = get_reactor();
+  select_reactor& r = get_reactor();
   update_cancellation_thread_id(impl);
 
   if ((impl.state_ & socket_ops::non_blocking) != 0
@@ -603,7 +645,7 @@ void win_iocp_socket_service_base::start_connect_op(
           || op->ec_ == asio::error::would_block)
       {
         op->ec_ = asio::error_code();
-        r.start_op(reactor::connect_op, impl.socket_,
+        r.start_op(select_reactor::connect_op, impl.socket_,
             impl.reactor_data_, op, false, false);
         return;
       }
@@ -618,20 +660,25 @@ void win_iocp_socket_service_base::close_for_destruction(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+    ASIO_HANDLER_OPERATION((iocp_service_.context(),
+          "socket", &impl, impl.socket_, "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.
-    reactor* r = static_cast<reactor*>(
+    select_reactor* r = static_cast<select_reactor*>(
           interlocked_compare_exchange_pointer(
             reinterpret_cast<void**>(&reactor_), 0, 0));
     if (r)
       r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
+
+    asio::error_code ignored_ec;
+    socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
+
+    if (r)
+      r->cleanup_descriptor_data(impl.reactor_data_);
   }
 
-  asio::error_code ignored_ec;
-  socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
   impl.socket_ = invalid_socket;
   impl.state_ = 0;
   impl.cancel_token_.reset();
@@ -653,14 +700,14 @@ void win_iocp_socket_service_base::update_cancellation_thread_id(
 #endif // defined(ASIO_ENABLE_CANCELIO)
 }
 
-reactor& win_iocp_socket_service_base::get_reactor()
+select_reactor& win_iocp_socket_service_base::get_reactor()
 {
-  reactor* r = static_cast<reactor*>(
+  select_reactor* r = static_cast<select_reactor*>(
         interlocked_compare_exchange_pointer(
           reinterpret_cast<void**>(&reactor_), 0, 0));
   if (!r)
   {
-    r = &(use_service<reactor>(io_service_));
+    r = &(use_service<select_reactor>(io_context_));
     interlocked_exchange_pointer(reinterpret_cast<void**>(&reactor_), r);
   }
   return *r;
@@ -701,6 +748,24 @@ win_iocp_socket_service_base::get_connect_ex(
 #endif // defined(ASIO_DISABLE_CONNECTEX)
 }
 
+win_iocp_socket_service_base::nt_set_info_fn
+win_iocp_socket_service_base::get_nt_set_info()
+{
+  void* ptr = interlocked_compare_exchange_pointer(&nt_set_info_, 0, 0);
+  if (!ptr)
+  {
+    if (HMODULE h = ::GetModuleHandleA("NTDLL.DLL"))
+      ptr = reinterpret_cast<void*>(GetProcAddress(h, "NtSetInformationFile"));
+
+    // On failure, set nt_set_info_ to a special value to indicate that the
+    // NtSetInformationFile function is unavailable. That way we won't bother
+    // trying to look it up again.
+    interlocked_exchange_pointer(&nt_set_info_, ptr ? ptr : this);
+  }
+
+  return reinterpret_cast<nt_set_info_fn>(ptr == this ? 0 : ptr);
+}
+
 void* win_iocp_socket_service_base::interlocked_compare_exchange_pointer(
     void** dest, void* exch, void* cmp)
 {
diff --git a/extern/include/asio/detail/impl/win_mutex.ipp b/extern/include/asio/detail/impl/win_mutex.ipp
index 608f4f58..dc58a12c 100644
--- a/extern/include/asio/detail/impl/win_mutex.ipp
+++ b/extern/include/asio/detail/impl/win_mutex.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -43,6 +43,9 @@ int win_mutex::do_init()
   // we'll just call the Windows API and hope.
 # if defined(UNDER_CE)
   ::InitializeCriticalSection(&crit_section_);
+# elif defined(ASIO_WINDOWS_APP)
+  if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0))
+    return ::GetLastError();
 # else
   if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
     return ::GetLastError();
@@ -53,6 +56,9 @@ int win_mutex::do_init()
   {
 # if defined(UNDER_CE)
     ::InitializeCriticalSection(&crit_section_);
+# elif defined(ASIO_WINDOWS_APP)
+    if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0))
+      return ::GetLastError();
 # else
     if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
       return ::GetLastError();
diff --git a/extern/include/asio/detail/impl/win_object_handle_service.ipp b/extern/include/asio/detail/impl/win_object_handle_service.ipp
index 8afeb8cf..c5e59d1b 100644
--- a/extern/include/asio/detail/impl/win_object_handle_service.ipp
+++ b/extern/include/asio/detail/impl/win_object_handle_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_object_handle_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -28,15 +28,16 @@ namespace asio {
 namespace detail {
 
 win_object_handle_service::win_object_handle_service(
-    asio::io_service& io_service)
-  : io_service_(asio::use_service<io_service_impl>(io_service)),
+    asio::io_context& io_context)
+  : service_base<win_object_handle_service>(io_context),
+    io_context_(asio::use_service<io_context_impl>(io_context)),
     mutex_(),
     impl_list_(0),
     shutdown_(false)
 {
 }
 
-void win_object_handle_service::shutdown_service()
+void win_object_handle_service::shutdown()
 {
   mutex::scoped_lock lock(mutex_);
 
@@ -51,7 +52,7 @@ void win_object_handle_service::shutdown_service()
 
   lock.unlock();
 
-  io_service_.abandon_operations(ops);
+  io_context_.abandon_operations(ops);
 }
 
 void win_object_handle_service::construct(
@@ -177,7 +178,8 @@ void win_object_handle_service::destroy(
 
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("object_handle", &impl, "close"));
+    ASIO_HANDLER_OPERATION((io_context_.context(), "object_handle",
+          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "close"));
 
     HANDLE wait_handle = impl.wait_handle_;
     impl.wait_handle_ = INVALID_HANDLE_VALUE;
@@ -201,7 +203,7 @@ void win_object_handle_service::destroy(
     ::CloseHandle(impl.handle_);
     impl.handle_ = INVALID_HANDLE_VALUE;
 
-    io_service_.post_deferred_completions(ops);
+    io_context_.post_deferred_completions(ops);
   }
 }
 
@@ -226,7 +228,8 @@ asio::error_code win_object_handle_service::close(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("object_handle", &impl, "close"));
+    ASIO_HANDLER_OPERATION((io_context_.context(), "object_handle",
+          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "close"));
 
     mutex::scoped_lock lock(mutex_);
 
@@ -261,7 +264,7 @@ asio::error_code win_object_handle_service::close(
           asio::error::get_system_category());
     }
 
-    io_service_.post_deferred_completions(completed_ops);
+    io_context_.post_deferred_completions(completed_ops);
   }
   else
   {
@@ -277,7 +280,8 @@ asio::error_code win_object_handle_service::cancel(
 {
   if (is_open(impl))
   {
-    ASIO_HANDLER_OPERATION(("object_handle", &impl, "cancel"));
+    ASIO_HANDLER_OPERATION((io_context_.context(), "object_handle",
+          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "cancel"));
 
     mutex::scoped_lock lock(mutex_);
 
@@ -302,7 +306,7 @@ asio::error_code win_object_handle_service::cancel(
 
     ec = asio::error_code();
 
-    io_service_.post_deferred_completions(completed_ops);
+    io_context_.post_deferred_completions(completed_ops);
   }
   else
   {
@@ -336,7 +340,7 @@ void win_object_handle_service::wait(
 void win_object_handle_service::start_wait_op(
     win_object_handle_service::implementation_type& impl, wait_op* op)
 {
-  io_service_.work_started();
+  io_context_.work_started();
 
   if (is_open(impl))
   {
@@ -354,13 +358,13 @@ void win_object_handle_service::start_wait_op(
     else
     {
       lock.unlock();
-      io_service_.post_deferred_completion(op);
+      io_context_.post_deferred_completion(op);
     }
   }
   else
   {
     op->ec_ = asio::error::bad_descriptor;
-    io_service_.post_deferred_completion(op);
+    io_context_.post_deferred_completion(op);
   }
 }
 
@@ -387,7 +391,7 @@ void win_object_handle_service::register_wait_callback(
     }
 
     lock.unlock();
-    io_service_.post_deferred_completions(completed_ops);
+    io_context_.post_deferred_completions(completed_ops);
   }
 }
 
@@ -429,9 +433,9 @@ void win_object_handle_service::wait_callback(PVOID param, BOOLEAN)
       }
     }
 
-    io_service_impl& ios = impl->owner_->io_service_;
+    io_context_impl& ioc = impl->owner_->io_context_;
     lock.unlock();
-    ios.post_deferred_completions(completed_ops);
+    ioc.post_deferred_completions(completed_ops);
   }
 }
 
diff --git a/extern/include/asio/detail/impl/win_static_mutex.ipp b/extern/include/asio/detail/impl/win_static_mutex.ipp
index 2654aa6a..42089bd5 100644
--- a/extern/include/asio/detail/impl/win_static_mutex.ipp
+++ b/extern/include/asio/detail/impl/win_static_mutex.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_static_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -49,13 +49,23 @@ int win_static_mutex::do_init()
       mutex_name, 128, L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p",
       static_cast<unsigned int>(::GetCurrentProcessId()), this);
 
+#if defined(ASIO_WINDOWS_APP)
+  HANDLE mutex = ::CreateMutexExW(0, mutex_name, CREATE_MUTEX_INITIAL_OWNER, 0);
+#else // defined(ASIO_WINDOWS_APP)
   HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name);
+#endif // defined(ASIO_WINDOWS_APP)
   DWORD last_error = ::GetLastError();
   if (mutex == 0)
     return ::GetLastError();
 
   if (last_error == ERROR_ALREADY_EXISTS)
+  {
+#if defined(ASIO_WINDOWS_APP)
+    ::WaitForSingleObjectEx(mutex, INFINITE, false);
+#else // defined(ASIO_WINDOWS_APP)
     ::WaitForSingleObject(mutex, INFINITE);
+#endif // defined(ASIO_WINDOWS_APP)
+  }
 
   if (initialised_)
   {
@@ -83,6 +93,14 @@ int win_static_mutex::do_init()
   {
 # if defined(UNDER_CE)
     ::InitializeCriticalSection(&crit_section_);
+# elif defined(ASIO_WINDOWS_APP)
+    if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0))
+    {
+      last_error = ::GetLastError();
+      ::ReleaseMutex(mutex);
+      ::CloseHandle(mutex);
+      return last_error;
+    }
 # else
     if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
     {
diff --git a/extern/include/asio/detail/impl/win_thread.ipp b/extern/include/asio/detail/impl/win_thread.ipp
index 70b2c85f..ed6dbafe 100644
--- a/extern/include/asio/detail/impl/win_thread.ipp
+++ b/extern/include/asio/detail/impl/win_thread.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_thread.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,7 +17,9 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_WINDOWS) && !defined(UNDER_CE)
+#if defined(ASIO_WINDOWS) \
+  && !defined(ASIO_WINDOWS_APP) \
+  && !defined(UNDER_CE)
 
 #include <process.h>
 #include "asio/detail/throw_error.hpp"
@@ -53,10 +55,17 @@ void win_thread::join()
   }
 }
 
+std::size_t win_thread::hardware_concurrency()
+{
+  SYSTEM_INFO system_info;
+  ::GetSystemInfo(&system_info);
+  return system_info.dwNumberOfProcessors;
+}
+
 void win_thread::start_thread(func_base* arg, unsigned int stack_size)
 {
   ::HANDLE entry_event = 0;
-  arg->entry_event_ = entry_event = ::CreateEvent(0, true, false, 0);
+  arg->entry_event_ = entry_event = ::CreateEventW(0, true, false, 0);
   if (!entry_event)
   {
     DWORD last_error = ::GetLastError();
@@ -66,7 +75,7 @@ void win_thread::start_thread(func_base* arg, unsigned int stack_size)
     asio::detail::throw_error(ec, "thread.entry_event");
   }
 
-  arg->exit_event_ = exit_event_ = ::CreateEvent(0, true, false, 0);
+  arg->exit_event_ = exit_event_ = ::CreateEventW(0, true, false, 0);
   if (!exit_event_)
   {
     DWORD last_error = ::GetLastError();
@@ -134,6 +143,8 @@ void __stdcall apc_function(ULONG_PTR) {}
 
 #include "asio/detail/pop_options.hpp"
 
-#endif // defined(ASIO_WINDOWS) && !defined(UNDER_CE)
+#endif // defined(ASIO_WINDOWS)
+       // && !defined(ASIO_WINDOWS_APP)
+       // && !defined(UNDER_CE)
 
 #endif // ASIO_DETAIL_IMPL_WIN_THREAD_IPP
diff --git a/extern/include/asio/detail/impl/win_tss_ptr.ipp b/extern/include/asio/detail/impl/win_tss_ptr.ipp
index 74414a3c..61df0ce2 100644
--- a/extern/include/asio/detail/impl/win_tss_ptr.ipp
+++ b/extern/include/asio/detail/impl/win_tss_ptr.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_tss_ptr.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,9 +31,9 @@ namespace detail {
 DWORD win_tss_ptr_create()
 {
 #if defined(UNDER_CE)
-  enum { out_of_indexes = 0xFFFFFFFF };
+  const DWORD out_of_indexes = 0xFFFFFFFF;
 #else
-  enum { out_of_indexes = TLS_OUT_OF_INDEXES };
+  const DWORD out_of_indexes = TLS_OUT_OF_INDEXES;
 #endif
 
   DWORD tss_key = ::TlsAlloc();
diff --git a/extern/include/asio/detail/impl/winrt_ssocket_service_base.ipp b/extern/include/asio/detail/impl/winrt_ssocket_service_base.ipp
index 06507004..288ca8b1 100644
--- a/extern/include/asio/detail/impl/winrt_ssocket_service_base.ipp
+++ b/extern/include/asio/detail/impl/winrt_ssocket_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/impl/winrt_ssocket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -30,15 +30,15 @@ namespace asio {
 namespace detail {
 
 winrt_ssocket_service_base::winrt_ssocket_service_base(
-    asio::io_service& io_service)
-  : io_service_(use_service<io_service_impl>(io_service)),
-    async_manager_(use_service<winrt_async_manager>(io_service)),
+    asio::io_context& io_context)
+  : io_context_(use_service<io_context_impl>(io_context)),
+    async_manager_(use_service<winrt_async_manager>(io_context)),
     mutex_(),
     impl_list_(0)
 {
 }
 
-void winrt_ssocket_service_base::shutdown_service()
+void winrt_ssocket_service_base::base_shutdown()
 {
   // Close all implementations, causing all operations to complete.
   asio::detail::mutex::scoped_lock lock(mutex_);
@@ -148,6 +148,23 @@ asio::error_code winrt_ssocket_service_base::close(
   return ec;
 }
 
+winrt_ssocket_service_base::native_handle_type
+winrt_ssocket_service_base::release(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (!is_open(impl))
+    return nullptr;
+
+  cancel(impl, ec);
+  if (ec)
+    return nullptr;
+
+  native_handle_type tmp = impl.socket_;
+  impl.socket_ = nullptr;
+  return tmp;
+}
+
 std::size_t winrt_ssocket_service_base::do_get_endpoint(
     const base_implementation_type& impl, bool local,
     void* addr, std::size_t addr_len, asio::error_code& ec) const
@@ -381,7 +398,7 @@ void winrt_ssocket_service_base::start_connect_op(
   if (!is_open(impl))
   {
     op->ec_ = asio::error::bad_descriptor;
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
     return;
   }
 
@@ -410,7 +427,7 @@ void winrt_ssocket_service_base::start_connect_op(
 
   if (op->ec_)
   {
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
     return;
   }
 
@@ -425,7 +442,7 @@ void winrt_ssocket_service_base::start_connect_op(
   {
     op->ec_ = asio::error_code(
         e->HResult, asio::system_category());
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
   }
 }
 
@@ -449,7 +466,7 @@ std::size_t winrt_ssocket_service_base::do_send(
   try
   {
     buffer_sequence_adapter<asio::const_buffer,
-      asio::const_buffers_1> bufs(asio::buffer(data));
+      asio::const_buffer> bufs(asio::buffer(data));
 
     if (bufs.all_empty())
     {
@@ -476,25 +493,25 @@ void winrt_ssocket_service_base::start_send_op(
   if (flags)
   {
     op->ec_ = asio::error::operation_not_supported;
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
     return;
   }
 
   if (!is_open(impl))
   {
     op->ec_ = asio::error::bad_descriptor;
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
     return;
   }
 
   try
   {
     buffer_sequence_adapter<asio::const_buffer,
-        asio::const_buffers_1> bufs(asio::buffer(data));
+        asio::const_buffer> bufs(asio::buffer(data));
 
     if (bufs.all_empty())
     {
-      io_service_.post_immediate_completion(op, is_continuation);
+      io_context_.post_immediate_completion(op, is_continuation);
       return;
     }
 
@@ -505,7 +522,7 @@ void winrt_ssocket_service_base::start_send_op(
   {
     op->ec_ = asio::error_code(e->HResult,
         asio::system_category());
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
   }
 }
 
@@ -529,7 +546,7 @@ std::size_t winrt_ssocket_service_base::do_receive(
   try
   {
     buffer_sequence_adapter<asio::mutable_buffer,
-        asio::mutable_buffers_1> bufs(asio::buffer(data));
+        asio::mutable_buffer> bufs(asio::buffer(data));
 
     if (bufs.all_empty())
     {
@@ -567,25 +584,25 @@ void winrt_ssocket_service_base::start_receive_op(
   if (flags)
   {
     op->ec_ = asio::error::operation_not_supported;
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
     return;
   }
 
   if (!is_open(impl))
   {
     op->ec_ = asio::error::bad_descriptor;
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
     return;
   }
 
   try
   {
     buffer_sequence_adapter<asio::mutable_buffer,
-        asio::mutable_buffers_1> bufs(asio::buffer(data));
+        asio::mutable_buffer> bufs(asio::buffer(data));
 
     if (bufs.all_empty())
     {
-      io_service_.post_immediate_completion(op, is_continuation);
+      io_context_.post_immediate_completion(op, is_continuation);
       return;
     }
 
@@ -598,7 +615,7 @@ void winrt_ssocket_service_base::start_receive_op(
   {
     op->ec_ = asio::error_code(e->HResult,
         asio::system_category());
-    io_service_.post_immediate_completion(op, is_continuation);
+    io_context_.post_immediate_completion(op, is_continuation);
   }
 }
 
diff --git a/extern/include/asio/detail/impl/winrt_timer_scheduler.hpp b/extern/include/asio/detail/impl/winrt_timer_scheduler.hpp
index 75b7472d..856378fe 100644
--- a/extern/include/asio/detail/impl/winrt_timer_scheduler.hpp
+++ b/extern/include/asio/detail/impl/winrt_timer_scheduler.hpp
@@ -2,7 +2,7 @@
 // detail/impl/winrt_timer_scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -46,12 +46,12 @@ void winrt_timer_scheduler::schedule_timer(timer_queue<Time_Traits>& queue,
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op, false);
+    io_context_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
+  io_context_.work_started();
   if (earliest)
     event_.signal(lock);
 }
@@ -65,10 +65,23 @@ std::size_t winrt_timer_scheduler::cancel_timer(timer_queue<Time_Traits>& queue,
   op_queue<operation> ops;
   std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
   lock.unlock();
-  io_service_.post_deferred_completions(ops);
+  io_context_.post_deferred_completions(ops);
   return n;
 }
 
+template <typename Time_Traits>
+void winrt_timer_scheduler::move_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& to,
+    typename timer_queue<Time_Traits>::per_timer_data& from)
+{
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer(to, ops);
+  queue.move_timer(to, from);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 } // namespace detail
 } // namespace asio
 
diff --git a/extern/include/asio/detail/impl/winrt_timer_scheduler.ipp b/extern/include/asio/detail/impl/winrt_timer_scheduler.ipp
index 77389173..ef213996 100644
--- a/extern/include/asio/detail/impl/winrt_timer_scheduler.ipp
+++ b/extern/include/asio/detail/impl/winrt_timer_scheduler.ipp
@@ -2,7 +2,7 @@
 // detail/impl/winrt_timer_scheduler.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,9 +28,9 @@ namespace asio {
 namespace detail {
 
 winrt_timer_scheduler::winrt_timer_scheduler(
-    asio::io_service& io_service)
-  : asio::detail::service_base<winrt_timer_scheduler>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
+    asio::io_context& io_context)
+  : asio::detail::service_base<winrt_timer_scheduler>(io_context),
+    io_context_(use_service<io_context_impl>(io_context)),
     mutex_(),
     event_(),
     timer_queues_(),
@@ -44,10 +44,10 @@ winrt_timer_scheduler::winrt_timer_scheduler(
 
 winrt_timer_scheduler::~winrt_timer_scheduler()
 {
-  shutdown_service();
+  shutdown();
 }
 
-void winrt_timer_scheduler::shutdown_service()
+void winrt_timer_scheduler::shutdown()
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
@@ -64,10 +64,10 @@ void winrt_timer_scheduler::shutdown_service()
 
   op_queue<operation> ops;
   timer_queues_.get_all_timers(ops);
-  io_service_.abandon_operations(ops);
+  io_context_.abandon_operations(ops);
 }
 
-void winrt_timer_scheduler::fork_service(asio::io_service::fork_event)
+void winrt_timer_scheduler::notify_fork(asio::io_context::fork_event)
 {
 }
 
@@ -89,7 +89,7 @@ void winrt_timer_scheduler::run_thread()
     if (!ops.empty())
     {
       lock.unlock();
-      io_service_.post_deferred_completions(ops);
+      io_context_.post_deferred_completions(ops);
       lock.lock();
     }
   }
diff --git a/extern/include/asio/detail/impl/winsock_init.ipp b/extern/include/asio/detail/impl/winsock_init.ipp
index 45cc9e06..da4b0c0b 100644
--- a/extern/include/asio/detail/impl/winsock_init.ipp
+++ b/extern/include/asio/detail/impl/winsock_init.ipp
@@ -2,7 +2,7 @@
 // detail/impl/winsock_init.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/io_control.hpp b/extern/include/asio/detail/io_control.hpp
index 625aba6a..12f35e09 100644
--- a/extern/include/asio/detail/io_control.hpp
+++ b/extern/include/asio/detail/io_control.hpp
@@ -2,7 +2,7 @@
 // detail/io_control.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,56 +25,6 @@ namespace asio {
 namespace detail {
 namespace io_control {
 
-// IO control command for non-blocking I/O.
-class non_blocking_io
-{
-public:
-  // Default constructor.
-  non_blocking_io()
-    : value_(0)
-  {
-  }
-
-  // Construct with a specific command value.
-  non_blocking_io(bool value)
-    : value_(value ? 1 : 0)
-  {
-  }
-
-  // Get the name of the IO control command.
-  int name() const
-  {
-    return static_cast<int>(ASIO_OS_DEF(FIONBIO));
-  }
-
-  // Set the value of the I/O control command.
-  void set(bool value)
-  {
-    value_ = value ? 1 : 0;
-  }
-
-  // Get the current value of the I/O control command.
-  bool get() const
-  {
-    return value_ != 0;
-  }
-
-  // Get the address of the command data.
-  detail::ioctl_arg_type* data()
-  {
-    return &value_;
-  }
-
-  // Get the address of the command data.
-  const detail::ioctl_arg_type* data() const
-  {
-    return &value_;
-  }
-
-private:
-  detail::ioctl_arg_type value_;
-};
-
 // I/O control command for getting number of bytes available.
 class bytes_readable
 {
diff --git a/extern/include/asio/detail/is_buffer_sequence.hpp b/extern/include/asio/detail/is_buffer_sequence.hpp
new file mode 100644
index 00000000..42ad0ebe
--- /dev/null
+++ b/extern/include/asio/detail/is_buffer_sequence.hpp
@@ -0,0 +1,239 @@
+//
+// detail/is_buffer_sequence.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
+#define ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+class mutable_buffer;
+class const_buffer;
+
+namespace detail {
+
+struct buffer_sequence_memfns_base
+{
+  void begin();
+  void end();
+  void size();
+  void max_size();
+  void capacity();
+  void data();
+  void prepare();
+  void commit();
+  void consume();
+};
+
+template <typename T>
+struct buffer_sequence_memfns_derived
+  : T, buffer_sequence_memfns_base
+{
+};
+
+template <typename T, T>
+struct buffer_sequence_memfns_check
+{
+};
+
+template <typename>
+char (&begin_memfn_helper(...))[2];
+
+template <typename T>
+char begin_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::begin>*);
+
+template <typename>
+char (&end_memfn_helper(...))[2];
+
+template <typename T>
+char end_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::end>*);
+
+template <typename>
+char (&size_memfn_helper(...))[2];
+
+template <typename T>
+char size_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::size>*);
+
+template <typename>
+char (&max_size_memfn_helper(...))[2];
+
+template <typename T>
+char max_size_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::max_size>*);
+
+template <typename>
+char (&capacity_memfn_helper(...))[2];
+
+template <typename T>
+char capacity_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::capacity>*);
+
+template <typename>
+char (&data_memfn_helper(...))[2];
+
+template <typename T>
+char data_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::data>*);
+
+template <typename>
+char (&prepare_memfn_helper(...))[2];
+
+template <typename T>
+char prepare_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::prepare>*);
+
+template <typename>
+char (&commit_memfn_helper(...))[2];
+
+template <typename T>
+char commit_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::commit>*);
+
+template <typename>
+char (&consume_memfn_helper(...))[2];
+
+template <typename T>
+char consume_memfn_helper(
+    buffer_sequence_memfns_check<
+      void (buffer_sequence_memfns_base::*)(),
+      &buffer_sequence_memfns_derived<T>::consume>*);
+
+template <typename, typename>
+char (&buffer_element_type_helper(...))[2];
+
+#if defined(ASIO_HAS_DECL_TYPE)
+
+template <typename T, typename Buffer>
+char buffer_element_type_helper(T* t,
+    typename enable_if<is_convertible<
+      decltype(*buffer_sequence_begin(*t)),
+        Buffer>::value>::type*);
+
+#else // defined(ASIO_HAS_DECL_TYPE)
+
+template <typename T, typename Buffer>
+char buffer_element_type_helper(
+    typename T::const_iterator*,
+    typename enable_if<is_convertible<
+      typename T::value_type, Buffer>::value>::type*);
+
+#endif // defined(ASIO_HAS_DECL_TYPE)
+
+template <typename>
+char (&const_buffers_type_typedef_helper(...))[2];
+
+template <typename T>
+char const_buffers_type_typedef_helper(
+    typename T::const_buffers_type*);
+
+template <typename>
+char (&mutable_buffers_type_typedef_helper(...))[2];
+
+template <typename T>
+char mutable_buffers_type_typedef_helper(
+    typename T::mutable_buffers_type*);
+
+template <typename T, typename Buffer>
+struct is_buffer_sequence_class
+  : integral_constant<bool,
+      sizeof(begin_memfn_helper<T>(0)) != 1 &&
+      sizeof(end_memfn_helper<T>(0)) != 1 &&
+      sizeof(buffer_element_type_helper<T, Buffer>(0, 0)) == 1>
+{
+};
+
+template <typename T, typename Buffer>
+struct is_buffer_sequence
+  : conditional<is_class<T>::value,
+      is_buffer_sequence_class<T, Buffer>,
+      false_type>::type
+{
+};
+
+template <>
+struct is_buffer_sequence<mutable_buffer, mutable_buffer>
+  : true_type
+{
+};
+
+template <>
+struct is_buffer_sequence<mutable_buffer, const_buffer>
+  : true_type
+{
+};
+
+template <>
+struct is_buffer_sequence<const_buffer, const_buffer>
+  : true_type
+{
+};
+
+template <>
+struct is_buffer_sequence<const_buffer, mutable_buffer>
+  : false_type
+{
+};
+
+template <typename T>
+struct is_dynamic_buffer_class
+  : integral_constant<bool,
+      sizeof(size_memfn_helper<T>(0)) != 1 &&
+      sizeof(max_size_memfn_helper<T>(0)) != 1 &&
+      sizeof(capacity_memfn_helper<T>(0)) != 1 &&
+      sizeof(data_memfn_helper<T>(0)) != 1 &&
+      sizeof(consume_memfn_helper<T>(0)) != 1 &&
+      sizeof(prepare_memfn_helper<T>(0)) != 1 &&
+      sizeof(commit_memfn_helper<T>(0)) != 1 &&
+      sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
+      sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
+{
+};
+
+template <typename T>
+struct is_dynamic_buffer
+  : conditional<is_class<T>::value,
+      is_dynamic_buffer_class<T>,
+      false_type>::type
+{
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
diff --git a/extern/include/asio/detail/is_executor.hpp b/extern/include/asio/detail/is_executor.hpp
new file mode 100644
index 00000000..4584dd04
--- /dev/null
+++ b/extern/include/asio/detail/is_executor.hpp
@@ -0,0 +1,126 @@
+//
+// detail/is_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IS_EXECUTOR_HPP
+#define ASIO_DETAIL_IS_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+struct executor_memfns_base
+{
+  void context();
+  void on_work_started();
+  void on_work_finished();
+  void dispatch();
+  void post();
+  void defer();
+};
+
+template <typename T>
+struct executor_memfns_derived
+  : T, executor_memfns_base
+{
+};
+
+template <typename T, T>
+struct executor_memfns_check
+{
+};
+
+template <typename>
+char (&context_memfn_helper(...))[2];
+
+template <typename T>
+char context_memfn_helper(
+    executor_memfns_check<
+      void (executor_memfns_base::*)(),
+      &executor_memfns_derived<T>::context>*);
+
+template <typename>
+char (&on_work_started_memfn_helper(...))[2];
+
+template <typename T>
+char on_work_started_memfn_helper(
+    executor_memfns_check<
+      void (executor_memfns_base::*)(),
+      &executor_memfns_derived<T>::on_work_started>*);
+
+template <typename>
+char (&on_work_finished_memfn_helper(...))[2];
+
+template <typename T>
+char on_work_finished_memfn_helper(
+    executor_memfns_check<
+      void (executor_memfns_base::*)(),
+      &executor_memfns_derived<T>::on_work_finished>*);
+
+template <typename>
+char (&dispatch_memfn_helper(...))[2];
+
+template <typename T>
+char dispatch_memfn_helper(
+    executor_memfns_check<
+      void (executor_memfns_base::*)(),
+      &executor_memfns_derived<T>::dispatch>*);
+
+template <typename>
+char (&post_memfn_helper(...))[2];
+
+template <typename T>
+char post_memfn_helper(
+    executor_memfns_check<
+      void (executor_memfns_base::*)(),
+      &executor_memfns_derived<T>::post>*);
+
+template <typename>
+char (&defer_memfn_helper(...))[2];
+
+template <typename T>
+char defer_memfn_helper(
+    executor_memfns_check<
+      void (executor_memfns_base::*)(),
+      &executor_memfns_derived<T>::defer>*);
+
+template <typename T>
+struct is_executor_class
+  : integral_constant<bool,
+      sizeof(context_memfn_helper<T>(0)) != 1 &&
+      sizeof(on_work_started_memfn_helper<T>(0)) != 1 &&
+      sizeof(on_work_finished_memfn_helper<T>(0)) != 1 &&
+      sizeof(dispatch_memfn_helper<T>(0)) != 1 &&
+      sizeof(post_memfn_helper<T>(0)) != 1 &&
+      sizeof(defer_memfn_helper<T>(0)) != 1>
+{
+};
+
+template <typename T>
+struct is_executor
+  : conditional<is_class<T>::value,
+      is_executor_class<T>,
+      false_type>::type
+{
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_IS_EXECUTOR_HPP
diff --git a/extern/include/asio/detail/keyword_tss_ptr.hpp b/extern/include/asio/detail/keyword_tss_ptr.hpp
index c4840bf3..2ae651ab 100644
--- a/extern/include/asio/detail/keyword_tss_ptr.hpp
+++ b/extern/include/asio/detail/keyword_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/keyword_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/kqueue_reactor.hpp b/extern/include/asio/detail/kqueue_reactor.hpp
index f2ab2138..43cb9f93 100644
--- a/extern/include/asio/detail/kqueue_reactor.hpp
+++ b/extern/include/asio/detail/kqueue_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/kqueue_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -35,7 +35,7 @@
 #include "asio/detail/timer_queue_set.hpp"
 #include "asio/detail/wait_op.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/execution_context.hpp"
 
 // Older versions of Mac OS X may not define EV_OOBAND.
 #if !defined(EV_OOBAND)
@@ -47,9 +47,15 @@
 namespace asio {
 namespace detail {
 
+class scheduler;
+
 class kqueue_reactor
-  : public asio::detail::service_base<kqueue_reactor>
+  : public execution_context_service_base<kqueue_reactor>
 {
+private:
+  // The mutex type used by this reactor.
+  typedef conditionally_enabled_mutex mutex;
+
 public:
   enum op_types { read_op = 0, write_op = 1,
     connect_op = 1, except_op = 2, max_ops = 3 };
@@ -57,6 +63,8 @@ class kqueue_reactor
   // Per-descriptor queues.
   struct descriptor_state
   {
+    descriptor_state(bool locking) : mutex_(locking) {}
+
     friend class kqueue_reactor;
     friend class object_pool_access;
 
@@ -74,17 +82,17 @@ class kqueue_reactor
   typedef descriptor_state* per_descriptor_data;
 
   // Constructor.
-  ASIO_DECL kqueue_reactor(asio::io_service& io_service);
+  ASIO_DECL kqueue_reactor(asio::execution_context& ctx);
 
   // Destructor.
   ASIO_DECL ~kqueue_reactor();
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Recreate internal descriptors following a fork.
-  ASIO_DECL void fork_service(
-      asio::io_service::fork_event fork_ev);
+  ASIO_DECL void notify_fork(
+      asio::execution_context::fork_event fork_ev);
 
   // Initialise the task.
   ASIO_DECL void init_task();
@@ -108,7 +116,7 @@ class kqueue_reactor
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op, is_continuation);
+    scheduler_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
@@ -124,14 +132,22 @@ class kqueue_reactor
       per_descriptor_data& descriptor_data);
 
   // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor.
+  // its registration from the reactor. The reactor resources associated with
+  // the descriptor must be released by calling cleanup_descriptor_data.
   ASIO_DECL void deregister_descriptor(socket_type descriptor,
       per_descriptor_data& descriptor_data, bool closing);
 
-  // Remote the descriptor's registration from the reactor.
+  // Remove the descriptor's registration from the reactor. The reactor
+  // resources associated with the descriptor must be released by calling
+  // cleanup_descriptor_data.
   ASIO_DECL void deregister_internal_descriptor(
       socket_type descriptor, per_descriptor_data& descriptor_data);
 
+  // Perform any post-deregistration cleanup tasks associated with the
+  // descriptor data.
+  ASIO_DECL void cleanup_descriptor_data(
+      per_descriptor_data& descriptor_data);
+
   // Add a new timer queue to the reactor.
   template <typename Time_Traits>
   void add_timer_queue(timer_queue<Time_Traits>& queue);
@@ -154,8 +170,14 @@ class kqueue_reactor
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Move the timer operations associated with the given timer.
+  template <typename Time_Traits>
+  void move_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& target,
+      typename timer_queue<Time_Traits>::per_timer_data& source);
+
   // Run the kqueue loop.
-  ASIO_DECL void run(bool block, op_queue<operation>& ops);
+  ASIO_DECL void run(long usec, op_queue<operation>& ops);
 
   // Interrupt the kqueue loop.
   ASIO_DECL void interrupt();
@@ -178,10 +200,10 @@ class kqueue_reactor
   ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
 
   // Get the timeout value for the kevent call.
-  ASIO_DECL timespec* get_timeout(timespec& ts);
+  ASIO_DECL timespec* get_timeout(long usec, timespec& ts);
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
+  // The scheduler used to post completions.
+  scheduler& scheduler_;
 
   // Mutex to protect access to internal data.
   mutex mutex_;
diff --git a/extern/include/asio/detail/local_free_on_block_exit.hpp b/extern/include/asio/detail/local_free_on_block_exit.hpp
index 2960deae..eba6b777 100644
--- a/extern/include/asio/detail/local_free_on_block_exit.hpp
+++ b/extern/include/asio/detail/local_free_on_block_exit.hpp
@@ -2,7 +2,7 @@
 // detail/local_free_on_block_exit.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,6 +18,7 @@
 #include "asio/detail/config.hpp"
 
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+#if !defined(ASIO_WINDOWS_APP)
 
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/socket_types.hpp"
@@ -52,6 +53,7 @@ class local_free_on_block_exit
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // !defined(ASIO_WINDOWS_APP)
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #endif // ASIO_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP
diff --git a/extern/include/asio/detail/macos_fenced_block.hpp b/extern/include/asio/detail/macos_fenced_block.hpp
index ce1c1e93..bbac270a 100644
--- a/extern/include/asio/detail/macos_fenced_block.hpp
+++ b/extern/include/asio/detail/macos_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/macos_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,7 @@
 #if defined(__MACH__) && defined(__APPLE__)
 
 #include <libkern/OSAtomic.h>
+#include "asio/detail/noncopyable.hpp"
 
 #include "asio/detail/push_options.hpp"
 
diff --git a/extern/include/asio/detail/memory.hpp b/extern/include/asio/detail/memory.hpp
new file mode 100644
index 00000000..b1ec4975
--- /dev/null
+++ b/extern/include/asio/detail/memory.hpp
@@ -0,0 +1,70 @@
+//
+// detail/memory.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_MEMORY_HPP
+#define ASIO_DETAIL_MEMORY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <memory>
+
+#if !defined(ASIO_HAS_STD_SHARED_PTR)
+# include <boost/shared_ptr.hpp>
+# include <boost/weak_ptr.hpp>
+#endif // !defined(ASIO_HAS_STD_SHARED_PTR)
+
+#if !defined(ASIO_HAS_STD_ADDRESSOF)
+# include <boost/utility/addressof.hpp>
+#endif // !defined(ASIO_HAS_STD_ADDRESSOF)
+
+namespace asio {
+namespace detail {
+
+#if defined(ASIO_HAS_STD_SHARED_PTR)
+using std::shared_ptr;
+using std::weak_ptr;
+#else // defined(ASIO_HAS_STD_SHARED_PTR)
+using boost::shared_ptr;
+using boost::weak_ptr;
+#endif // defined(ASIO_HAS_STD_SHARED_PTR)
+
+#if defined(ASIO_HAS_STD_ADDRESSOF)
+using std::addressof;
+#else // defined(ASIO_HAS_STD_ADDRESSOF)
+using boost::addressof;
+#endif // defined(ASIO_HAS_STD_ADDRESSOF)
+
+} // namespace detail
+
+#if defined(ASIO_HAS_CXX11_ALLOCATORS)
+using std::allocator_arg_t;
+# define ASIO_USES_ALLOCATOR(t) \
+  namespace std { \
+    template <typename Allocator> \
+    struct uses_allocator<t, Allocator> : true_type {}; \
+  } \
+  /**/
+# define ASIO_REBIND_ALLOC(alloc, t) \
+  typename std::allocator_traits<alloc>::template rebind_alloc<t>
+  /**/
+#else // defined(ASIO_HAS_CXX11_ALLOCATORS)
+struct allocator_arg_t {};
+# define ASIO_USES_ALLOCATOR(t)
+# define ASIO_REBIND_ALLOC(alloc, t) \
+  typename alloc::template rebind<t>::other
+  /**/
+#endif // defined(ASIO_HAS_CXX11_ALLOCATORS)
+
+} // namespace asio
+
+#endif // ASIO_DETAIL_MEMORY_HPP
diff --git a/extern/include/asio/detail/mutex.hpp b/extern/include/asio/detail/mutex.hpp
index 35885ade..2f8f0b13 100644
--- a/extern/include/asio/detail/mutex.hpp
+++ b/extern/include/asio/detail/mutex.hpp
@@ -2,7 +2,7 @@
 // detail/mutex.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/noncopyable.hpp b/extern/include/asio/detail/noncopyable.hpp
index db5ac4c4..0c038e11 100644
--- a/extern/include/asio/detail/noncopyable.hpp
+++ b/extern/include/asio/detail/noncopyable.hpp
@@ -2,7 +2,7 @@
 // detail/noncopyable.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/null_event.hpp b/extern/include/asio/detail/null_event.hpp
index 394bb163..5686a41e 100644
--- a/extern/include/asio/detail/null_event.hpp
+++ b/extern/include/asio/detail/null_event.hpp
@@ -2,7 +2,7 @@
 // detail/null_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,9 +16,6 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-
 #include "asio/detail/noncopyable.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -75,7 +72,20 @@ class null_event
   template <typename Lock>
   void wait(Lock&)
   {
+    do_wait();
   }
+
+  // Timed wait for the event to become signalled.
+  template <typename Lock>
+  bool wait_for_usec(Lock&, long usec)
+  {
+    do_wait_for_usec(usec);
+    return true;
+  }
+
+private:
+  ASIO_DECL static void do_wait();
+  ASIO_DECL static void do_wait_for_usec(long usec);
 };
 
 } // namespace detail
@@ -83,6 +93,8 @@ class null_event
 
 #include "asio/detail/pop_options.hpp"
 
-#endif // !defined(ASIO_HAS_THREADS)
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/detail/impl/null_event.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
 
 #endif // ASIO_DETAIL_NULL_EVENT_HPP
diff --git a/extern/include/asio/detail/null_fenced_block.hpp b/extern/include/asio/detail/null_fenced_block.hpp
index 0592de09..0275326b 100644
--- a/extern/include/asio/detail/null_fenced_block.hpp
+++ b/extern/include/asio/detail/null_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/null_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/detail/noncopyable.hpp"
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
diff --git a/extern/include/asio/detail/null_global.hpp b/extern/include/asio/detail/null_global.hpp
new file mode 100644
index 00000000..727dd3f4
--- /dev/null
+++ b/extern/include/asio/detail/null_global.hpp
@@ -0,0 +1,59 @@
+//
+// detail/null_global.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_NULL_GLOBAL_HPP
+#define ASIO_DETAIL_NULL_GLOBAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+struct null_global_impl
+{
+  null_global_impl()
+    : ptr_(0)
+  {
+  }
+
+  // Destructor automatically cleans up the global.
+  ~null_global_impl()
+  {
+    delete ptr_;
+  }
+
+  static null_global_impl instance_;
+  T* ptr_;
+};
+
+template <typename T>
+null_global_impl<T> null_global_impl<T>::instance_;
+
+template <typename T>
+T& null_global()
+{
+  if (null_global_impl<T>::instance_.ptr_ == 0)
+    null_global_impl<T>::instance_.ptr_ = new T;
+  return *null_global_impl<T>::instance_.ptr_;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_NULL_GLOBAL_HPP
diff --git a/extern/include/asio/detail/null_mutex.hpp b/extern/include/asio/detail/null_mutex.hpp
index 4ee92e40..afe3fc03 100644
--- a/extern/include/asio/detail/null_mutex.hpp
+++ b/extern/include/asio/detail/null_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/null_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/null_reactor.hpp b/extern/include/asio/detail/null_reactor.hpp
index cc8c4770..ca3c5fde 100644
--- a/extern/include/asio/detail/null_reactor.hpp
+++ b/extern/include/asio/detail/null_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/null_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,10 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_WINDOWS_RUNTIME)
+#if defined(ASIO_HAS_IOCP) || defined(ASIO_WINDOWS_RUNTIME)
 
-#include "asio/io_service.hpp"
+#include "asio/detail/scheduler_operation.hpp"
+#include "asio/execution_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -27,12 +28,12 @@ namespace asio {
 namespace detail {
 
 class null_reactor
-  : public asio::detail::service_base<null_reactor>
+  : public execution_context_service_base<null_reactor>
 {
 public:
   // Constructor.
-  null_reactor(asio::io_service& io_service)
-    : asio::detail::service_base<null_reactor>(io_service)
+  null_reactor(asio::execution_context& ctx)
+    : execution_context_service_base<null_reactor>(ctx)
   {
   }
 
@@ -42,12 +43,12 @@ class null_reactor
   }
 
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
   }
 
   // No-op because should never be called.
-  void run(bool /*block*/, op_queue<operation>& /*ops*/)
+  void run(long /*usec*/, op_queue<scheduler_operation>& /*ops*/)
   {
   }
 
@@ -62,6 +63,6 @@ class null_reactor
 
 #include "asio/detail/pop_options.hpp"
 
-#endif // defined(ASIO_WINDOWS_RUNTIME)
+#endif // defined(ASIO_HAS_IOCP) || defined(ASIO_WINDOWS_RUNTIME)
 
 #endif // ASIO_DETAIL_NULL_REACTOR_HPP
diff --git a/extern/include/asio/detail/null_signal_blocker.hpp b/extern/include/asio/detail/null_signal_blocker.hpp
index 43ed011a..edfe8205 100644
--- a/extern/include/asio/detail/null_signal_blocker.hpp
+++ b/extern/include/asio/detail/null_signal_blocker.hpp
@@ -2,7 +2,7 @@
 // detail/null_signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/null_socket_service.hpp b/extern/include/asio/detail/null_socket_service.hpp
index c991720e..109c6c7b 100644
--- a/extern/include/asio/detail/null_socket_service.hpp
+++ b/extern/include/asio/detail/null_socket_service.hpp
@@ -2,7 +2,7 @@
 // detail/null_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,7 +21,7 @@
 
 #include "asio/buffer.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/socket_base.hpp"
 #include "asio/detail/bind_handler.hpp"
 
@@ -31,7 +31,8 @@ namespace asio {
 namespace detail {
 
 template <typename Protocol>
-class null_socket_service
+class null_socket_service :
+  public service_base<null_socket_service<Protocol> >
 {
 public:
   // The protocol type.
@@ -49,13 +50,14 @@ class null_socket_service
   };
 
   // Constructor.
-  null_socket_service(asio::io_service& io_service)
-    : io_service_(io_service)
+  null_socket_service(asio::io_context& io_context)
+    : service_base<null_socket_service<Protocol> >(io_context),
+      io_context_(io_context)
   {
   }
 
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
   }
 
@@ -78,6 +80,7 @@ class null_socket_service
   // Move-construct a new socket implementation from another protocol type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type&,
+      null_socket_service<Protocol1>&,
       typename null_socket_service<Protocol1>::implementation_type&)
   {
   }
@@ -117,6 +120,14 @@ class null_socket_service
     return ec;
   }
 
+  // Release ownership of the socket.
+  native_handle_type release(implementation_type&,
+      asio::error_code& ec)
+  {
+    ec = asio::error::operation_not_supported;
+    return 0;
+  }
+
   // Get the native socket representation.
   native_handle_type native_handle(implementation_type&)
   {
@@ -267,7 +278,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Start an asynchronous wait until data can be sent without blocking.
@@ -277,7 +288,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Receive some data from the peer. Returns the number of bytes received.
@@ -305,7 +316,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Wait until data can be received without blocking.
@@ -315,7 +326,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Receive some data with associated flags. Returns the number of bytes
@@ -347,7 +358,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Wait until data can be received without blocking.
@@ -358,7 +369,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Send a datagram to the specified endpoint. Returns the number of bytes
@@ -390,7 +401,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Start an asynchronous wait until data can be sent without blocking.
@@ -400,7 +411,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Receive a datagram with the endpoint of the sender. Returns the number of
@@ -433,7 +444,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Wait until data can be received without blocking.
@@ -444,7 +455,7 @@ class null_socket_service
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+    io_context_.post(detail::bind_handler(handler, ec, bytes_transferred));
   }
 
   // Accept a new connection.
@@ -463,7 +474,7 @@ class null_socket_service
       endpoint_type*, Handler& handler)
   {
     asio::error_code ec = asio::error::operation_not_supported;
-    io_service_.post(detail::bind_handler(handler, ec));
+    io_context_.post(detail::bind_handler(handler, ec));
   }
 
   // Connect the socket to the specified endpoint.
@@ -480,11 +491,11 @@ class null_socket_service
       const endpoint_type&, Handler& handler)
   {
     asio::error_code ec = asio::error::operation_not_supported;
-    io_service_.post(detail::bind_handler(handler, ec));
+    io_context_.post(detail::bind_handler(handler, ec));
   }
 
 private:
-  asio::io_service& io_service_;
+  asio::io_context& io_context_;
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/null_static_mutex.hpp b/extern/include/asio/detail/null_static_mutex.hpp
index af4dfec0..36ec04f7 100644
--- a/extern/include/asio/detail/null_static_mutex.hpp
+++ b/extern/include/asio/detail/null_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/null_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/null_thread.hpp b/extern/include/asio/detail/null_thread.hpp
index 79a93220..7291ba38 100644
--- a/extern/include/asio/detail/null_thread.hpp
+++ b/extern/include/asio/detail/null_thread.hpp
@@ -2,7 +2,7 @@
 // detail/null_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -49,6 +49,12 @@ class null_thread
   void join()
   {
   }
+
+  // Get number of CPUs.
+  static std::size_t hardware_concurrency()
+  {
+    return 1;
+  }
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/null_tss_ptr.hpp b/extern/include/asio/detail/null_tss_ptr.hpp
index 2ba1c9fe..323967d6 100644
--- a/extern/include/asio/detail/null_tss_ptr.hpp
+++ b/extern/include/asio/detail/null_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/null_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/object_pool.hpp b/extern/include/asio/detail/object_pool.hpp
index 53e22f6e..e1a3c548 100644
--- a/extern/include/asio/detail/object_pool.hpp
+++ b/extern/include/asio/detail/object_pool.hpp
@@ -2,7 +2,7 @@
 // detail/object_pool.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -34,6 +34,12 @@ class object_pool_access
     return new Object;
   }
 
+  template <typename Object, typename Arg>
+  static Object* create(Arg arg)
+  {
+    return new Object(arg);
+  }
+
   template <typename Object>
   static void destroy(Object* o)
   {
@@ -96,6 +102,25 @@ class object_pool
     return o;
   }
 
+  // Allocate a new object with an argument.
+  template <typename Arg>
+  Object* alloc(Arg arg)
+  {
+    Object* o = free_list_;
+    if (o)
+      free_list_ = object_pool_access::next(free_list_);
+    else
+      o = object_pool_access::create<Object>(arg);
+
+    object_pool_access::next(o) = live_list_;
+    object_pool_access::prev(o) = 0;
+    if (live_list_)
+      object_pool_access::prev(live_list_) = o;
+    live_list_ = o;
+
+    return o;
+  }
+
   // Free an object. Moves it to the free list. No destructors are run.
   void free(Object* o)
   {
diff --git a/extern/include/asio/detail/old_win_sdk_compat.hpp b/extern/include/asio/detail/old_win_sdk_compat.hpp
index f1681828..bfb109e7 100644
--- a/extern/include/asio/detail/old_win_sdk_compat.hpp
+++ b/extern/include/asio/detail/old_win_sdk_compat.hpp
@@ -2,7 +2,7 @@
 // detail/old_win_sdk_compat.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/op_queue.hpp b/extern/include/asio/detail/op_queue.hpp
index 38076beb..6219f797 100644
--- a/extern/include/asio/detail/op_queue.hpp
+++ b/extern/include/asio/detail/op_queue.hpp
@@ -2,7 +2,7 @@
 // detail/op_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -138,6 +138,12 @@ class op_queue
     return front_ == 0;
   }
 
+  // Test whether an operation is already enqueued.
+  bool is_enqueued(Operation* o) const
+  {
+    return op_queue_access::next(o) != 0 || back_ == o;
+  }
+
 private:
   friend class op_queue_access;
 
diff --git a/extern/include/asio/detail/operation.hpp b/extern/include/asio/detail/operation.hpp
index 637ec15d..811e54d4 100644
--- a/extern/include/asio/detail/operation.hpp
+++ b/extern/include/asio/detail/operation.hpp
@@ -2,7 +2,7 @@
 // detail/operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,7 +20,7 @@
 #if defined(ASIO_HAS_IOCP)
 # include "asio/detail/win_iocp_operation.hpp"
 #else
-# include "asio/detail/task_io_service_operation.hpp"
+# include "asio/detail/scheduler_operation.hpp"
 #endif
 
 namespace asio {
@@ -29,7 +29,7 @@ namespace detail {
 #if defined(ASIO_HAS_IOCP)
 typedef win_iocp_operation operation;
 #else
-typedef task_io_service_operation operation;
+typedef scheduler_operation operation;
 #endif
 
 } // namespace detail
diff --git a/extern/include/asio/detail/pipe_select_interrupter.hpp b/extern/include/asio/detail/pipe_select_interrupter.hpp
index 57e211e8..55d7db49 100644
--- a/extern/include/asio/detail/pipe_select_interrupter.hpp
+++ b/extern/include/asio/detail/pipe_select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/pipe_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/pop_options.hpp b/extern/include/asio/detail/pop_options.hpp
index a41c1a0b..1045612b 100644
--- a/extern/include/asio/detail/pop_options.hpp
+++ b/extern/include/asio/detail/pop_options.hpp
@@ -2,7 +2,7 @@
 // detail/pop_options.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -67,6 +67,10 @@
 #  pragma GCC visibility pop
 # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 
+# if (__GNUC__ >= 7)
+#  pragma GCC diagnostic pop
+# endif // (__GNUC__ >= 7)
+
 #elif defined(__KCC)
 
 // Kai C++
diff --git a/extern/include/asio/detail/posix_event.hpp b/extern/include/asio/detail/posix_event.hpp
index 984b70f4..121065ef 100644
--- a/extern/include/asio/detail/posix_event.hpp
+++ b/extern/include/asio/detail/posix_event.hpp
@@ -2,7 +2,7 @@
 // detail/posix_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -107,6 +107,42 @@ class posix_event
     }
   }
 
+  // Timed wait for the event to become signalled.
+  template <typename Lock>
+  bool wait_for_usec(Lock& lock, long usec)
+  {
+    ASIO_ASSERT(lock.locked());
+    if ((state_ & 1) == 0)
+    {
+      state_ += 2;
+      timespec ts;
+#if (defined(__MACH__) && defined(__APPLE__)) \
+      || (defined(__ANDROID__) && (__ANDROID_API__ < 21) \
+          && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE))
+      ts.tv_sec = usec / 1000000;
+      ts.tv_nsec = (usec % 1000000) * 1000;
+      ::pthread_cond_timedwait_relative_np(
+          &cond_, &lock.mutex().mutex_, &ts); // Ignore EINVAL.
+#else // (defined(__MACH__) && defined(__APPLE__))
+      // || (defined(__ANDROID__) && (__ANDROID_API__ < 21)
+      //     && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE))
+      if (::clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
+      {
+        ts.tv_sec += usec / 1000000;
+        ts.tv_nsec = (usec % 1000000) * 1000;
+        ts.tv_sec += ts.tv_nsec / 1000000000;
+        ts.tv_nsec = ts.tv_nsec % 1000000000;
+        ::pthread_cond_timedwait(&cond_,
+            &lock.mutex().mutex_, &ts); // Ignore EINVAL.
+      }
+#endif // (defined(__MACH__) && defined(__APPLE__))
+       // || (defined(__ANDROID__) && (__ANDROID_API__ < 21)
+       //     && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE))
+      state_ -= 2;
+    }
+    return (state_ & 1) != 0;
+  }
+
 private:
   ::pthread_cond_t cond_;
   std::size_t state_;
diff --git a/extern/include/asio/detail/posix_fd_set_adapter.hpp b/extern/include/asio/detail/posix_fd_set_adapter.hpp
index 2ea97b69..95042d66 100644
--- a/extern/include/asio/detail/posix_fd_set_adapter.hpp
+++ b/extern/include/asio/detail/posix_fd_set_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/posix_fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/posix_global.hpp b/extern/include/asio/detail/posix_global.hpp
new file mode 100644
index 00000000..7ee0a715
--- /dev/null
+++ b/extern/include/asio/detail/posix_global.hpp
@@ -0,0 +1,80 @@
+//
+// detail/posix_global.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_POSIX_GLOBAL_HPP
+#define ASIO_DETAIL_POSIX_GLOBAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_PTHREADS)
+
+#include <exception>
+#include <pthread.h>
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+struct posix_global_impl
+{
+  // Helper function to perform initialisation.
+  static void do_init()
+  {
+    instance_.static_ptr_ = instance_.ptr_ = new T;
+  }
+
+  // Destructor automatically cleans up the global.
+  ~posix_global_impl()
+  {
+    delete static_ptr_;
+  }
+
+  static ::pthread_once_t init_once_;
+  static T* static_ptr_;
+  static posix_global_impl instance_;
+  T* ptr_;
+};
+
+template <typename T>
+::pthread_once_t posix_global_impl<T>::init_once_ = PTHREAD_ONCE_INIT;
+
+template <typename T>
+T* posix_global_impl<T>::static_ptr_ = 0;
+
+template <typename T>
+posix_global_impl<T> posix_global_impl<T>::instance_;
+
+template <typename T>
+T& posix_global()
+{
+  int result = ::pthread_once(
+      &posix_global_impl<T>::init_once_,
+      &posix_global_impl<T>::do_init);
+
+  if (result != 0)
+    std::terminate();
+
+  return *posix_global_impl<T>::instance_.ptr_;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_PTHREADS)
+
+#endif // ASIO_DETAIL_POSIX_GLOBAL_HPP
diff --git a/extern/include/asio/detail/posix_mutex.hpp b/extern/include/asio/detail/posix_mutex.hpp
index 783bc56a..c0d9fc9b 100644
--- a/extern/include/asio/detail/posix_mutex.hpp
+++ b/extern/include/asio/detail/posix_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/posix_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/posix_signal_blocker.hpp b/extern/include/asio/detail/posix_signal_blocker.hpp
index d344c32c..fab5eb12 100644
--- a/extern/include/asio/detail/posix_signal_blocker.hpp
+++ b/extern/include/asio/detail/posix_signal_blocker.hpp
@@ -2,7 +2,7 @@
 // detail/posix_signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/posix_static_mutex.hpp b/extern/include/asio/detail/posix_static_mutex.hpp
index 72bd2f48..59b86c18 100644
--- a/extern/include/asio/detail/posix_static_mutex.hpp
+++ b/extern/include/asio/detail/posix_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/posix_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/posix_thread.hpp b/extern/include/asio/detail/posix_thread.hpp
index 2855c634..1817af28 100644
--- a/extern/include/asio/detail/posix_thread.hpp
+++ b/extern/include/asio/detail/posix_thread.hpp
@@ -2,7 +2,7 @@
 // detail/posix_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,7 @@
 
 #if defined(ASIO_HAS_PTHREADS)
 
+#include <cstddef>
 #include <pthread.h>
 #include "asio/detail/noncopyable.hpp"
 
@@ -50,6 +51,9 @@ class posix_thread
   // Wait for the thread to exit.
   ASIO_DECL void join();
 
+  // Get number of CPUs.
+  ASIO_DECL static std::size_t hardware_concurrency();
+
 private:
   friend void* asio_detail_posix_thread_function(void* arg);
 
diff --git a/extern/include/asio/detail/posix_tss_ptr.hpp b/extern/include/asio/detail/posix_tss_ptr.hpp
index fd7e9deb..a3096b43 100644
--- a/extern/include/asio/detail/posix_tss_ptr.hpp
+++ b/extern/include/asio/detail/posix_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/posix_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/push_options.hpp b/extern/include/asio/detail/push_options.hpp
index 212c2233..0a3e9798 100644
--- a/extern/include/asio/detail/push_options.hpp
+++ b/extern/include/asio/detail/push_options.hpp
@@ -2,7 +2,7 @@
 // detail/push_options.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -71,6 +71,11 @@
 #  pragma GCC visibility push (default)
 # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 
+# if (__GNUC__ >= 7)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+# endif // (__GNUC__ >= 7)
+
 #elif defined(__KCC)
 
 // Kai C++
@@ -135,6 +140,10 @@
 # pragma warning (disable:4512)
 # pragma warning (disable:4610)
 # pragma warning (disable:4675)
+# if (_MSC_VER < 1600)
+// Visual Studio 2008 generates spurious warnings about unused parameters.
+#  pragma warning (disable:4100)
+# endif // (_MSC_VER < 1600)
 # if defined(_M_IX86) && defined(_Wp64)
 // The /Wp64 option is broken. If you want to check 64 bit portability, use a
 // 64 bit compiler!
diff --git a/extern/include/asio/detail/reactive_descriptor_service.hpp b/extern/include/asio/detail/reactive_descriptor_service.hpp
index e116ed22..e8668639 100644
--- a/extern/include/asio/detail/reactive_descriptor_service.hpp
+++ b/extern/include/asio/detail/reactive_descriptor_service.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_descriptor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,24 +22,27 @@
   && !defined(__CYGWIN__)
 
 #include "asio/buffer.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/descriptor_ops.hpp"
 #include "asio/detail/descriptor_read_op.hpp"
 #include "asio/detail/descriptor_write_op.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/reactive_null_buffers_op.hpp"
+#include "asio/detail/reactive_wait_op.hpp"
 #include "asio/detail/reactor.hpp"
+#include "asio/posix/descriptor_base.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-class reactive_descriptor_service
+class reactive_descriptor_service :
+  public service_base<reactive_descriptor_service>
 {
 public:
   // The native type of a descriptor.
@@ -73,10 +76,10 @@ class reactive_descriptor_service
 
   // Constructor.
   ASIO_DECL reactive_descriptor_service(
-      asio::io_service& io_service);
+      asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Construct a new descriptor implementation.
   ASIO_DECL void construct(implementation_type& impl);
@@ -161,6 +164,71 @@ class reactive_descriptor_service
     return ec;
   }
 
+  // Wait for the descriptor to become ready to read, ready to write, or to have
+  // pending error conditions.
+  asio::error_code wait(implementation_type& impl,
+      posix::descriptor_base::wait_type w, asio::error_code& ec)
+  {
+    switch (w)
+    {
+    case posix::descriptor_base::wait_read:
+      descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
+      break;
+    case posix::descriptor_base::wait_write:
+      descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
+      break;
+    case posix::descriptor_base::wait_error:
+      descriptor_ops::poll_error(impl.descriptor_, impl.state_, ec);
+      break;
+    default:
+      ec = asio::error::invalid_argument;
+      break;
+    }
+
+    return ec;
+  }
+
+  // Asynchronously wait for the descriptor to become ready to read, ready to
+  // write, or to have pending error conditions.
+  template <typename Handler>
+  void async_wait(implementation_type& impl,
+      posix::descriptor_base::wait_type w, Handler& handler)
+  {
+    bool is_continuation =
+      asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef reactive_wait_op<Handler> op;
+    typename op::ptr p = { asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(handler);
+
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
+          &impl, impl.descriptor_, "async_wait"));
+
+    int op_type;
+    switch (w)
+    {
+    case posix::descriptor_base::wait_read:
+        op_type = reactor::read_op;
+        break;
+    case posix::descriptor_base::wait_write:
+        op_type = reactor::write_op;
+        break;
+    case posix::descriptor_base::wait_error:
+        op_type = reactor::except_op;
+        break;
+      default:
+        p.p->ec_ = asio::error::invalid_argument;
+        reactor_.post_immediate_completion(p.p, is_continuation);
+        p.v = p.p = 0;
+        return;
+    }
+
+    start_op(impl, op_type, p.p, is_continuation, false, false);
+    p.v = p.p = 0;
+  }
+
   // Write some data to the descriptor.
   template <typename ConstBufferSequence>
   size_t write_some(implementation_type& impl,
@@ -195,11 +263,11 @@ class reactive_descriptor_service
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_write_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.descriptor_, buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_write_some"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
+          &impl, impl.descriptor_, "async_write_some"));
 
     start_op(impl, reactor::write_op, p.p, is_continuation, true,
         buffer_sequence_adapter<asio::const_buffer,
@@ -218,12 +286,11 @@ class reactive_descriptor_service
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "descriptor",
-          &impl, "async_write_some(null_buffers)"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
+          &impl, impl.descriptor_, "async_write_some(null_buffers)"));
 
     start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
@@ -263,11 +330,11 @@ class reactive_descriptor_service
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_read_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.descriptor_, buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_read_some"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
+          &impl, impl.descriptor_, "async_read_some"));
 
     start_op(impl, reactor::read_op, p.p, is_continuation, true,
         buffer_sequence_adapter<asio::mutable_buffer,
@@ -286,12 +353,11 @@ class reactive_descriptor_service
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "descriptor",
-          &impl, "async_read_some(null_buffers)"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
+          &impl, impl.descriptor_, "async_read_some(null_buffers)"));
 
     start_op(impl, reactor::read_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
diff --git a/extern/include/asio/detail/reactive_null_buffers_op.hpp b/extern/include/asio/detail/reactive_null_buffers_op.hpp
index b7138172..74082692 100644
--- a/extern/include/asio/detail/reactive_null_buffers_op.hpp
+++ b/extern/include/asio/detail/reactive_null_buffers_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_null_buffers_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -38,22 +38,24 @@ class reactive_null_buffers_op : public reactor_op
         &reactive_null_buffers_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static bool do_perform(reactor_op*)
+  static status do_perform(reactor_op*)
   {
-    return true;
+    return done;
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -71,7 +73,7 @@ class reactive_null_buffers_op : public reactor_op
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/reactive_serial_port_service.hpp b/extern/include/asio/detail/reactive_serial_port_service.hpp
index efac78ed..6fddd9f1 100644
--- a/extern/include/asio/detail/reactive_serial_port_service.hpp
+++ b/extern/include/asio/detail/reactive_serial_port_service.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_serial_port_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -23,7 +23,7 @@
 
 #include <string>
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/serial_port_base.hpp"
 #include "asio/detail/descriptor_ops.hpp"
 #include "asio/detail/reactive_descriptor_service.hpp"
@@ -34,7 +34,8 @@ namespace asio {
 namespace detail {
 
 // Extend reactive_descriptor_service to provide serial port support.
-class reactive_serial_port_service
+class reactive_serial_port_service :
+  public service_base<reactive_serial_port_service>
 {
 public:
   // The native type of a serial port.
@@ -44,10 +45,10 @@ class reactive_serial_port_service
   typedef reactive_descriptor_service::implementation_type implementation_type;
 
   ASIO_DECL reactive_serial_port_service(
-      asio::io_service& io_service);
+      asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Construct a new serial port implementation.
   void construct(implementation_type& impl)
@@ -189,8 +190,8 @@ class reactive_serial_port_service
   static asio::error_code store_option(const void* option,
       termios& storage, asio::error_code& ec)
   {
-    return static_cast<const SettableSerialPortOption*>(option)->store(
-        storage, ec);
+    static_cast<const SettableSerialPortOption*>(option)->store(storage, ec);
+    return ec;
   }
 
   // Helper function to set a serial port option.
@@ -207,7 +208,8 @@ class reactive_serial_port_service
   static asio::error_code load_option(void* option,
       const termios& storage, asio::error_code& ec)
   {
-    return static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
+    static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
+    return ec;
   }
 
   // Helper function to get a serial port option.
diff --git a/extern/include/asio/detail/reactive_socket_accept_op.hpp b/extern/include/asio/detail/reactive_socket_accept_op.hpp
index 0687e0f7..4a98f047 100644
--- a/extern/include/asio/detail/reactive_socket_accept_op.hpp
+++ b/extern/include/asio/detail/reactive_socket_accept_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_accept_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_holder.hpp"
 #include "asio/detail/socket_ops.hpp"
@@ -41,40 +41,48 @@ class reactive_socket_accept_op_base : public reactor_op
       state_(state),
       peer_(peer),
       protocol_(protocol),
-      peer_endpoint_(peer_endpoint)
+      peer_endpoint_(peer_endpoint),
+      addrlen_(peer_endpoint ? peer_endpoint->capacity() : 0)
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     reactive_socket_accept_op_base* o(
         static_cast<reactive_socket_accept_op_base*>(base));
 
-    std::size_t addrlen = o->peer_endpoint_ ? o->peer_endpoint_->capacity() : 0;
     socket_type new_socket = invalid_socket;
-    bool result = socket_ops::non_blocking_accept(o->socket_,
-          o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
-          o->peer_endpoint_ ? &addrlen : 0, o->ec_, new_socket);
+    status result = socket_ops::non_blocking_accept(o->socket_,
+        o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
+        o->peer_endpoint_ ? &o->addrlen_ : 0, o->ec_, new_socket)
+    ? done : not_done;
+    o->new_socket_.reset(new_socket);
 
-    // On success, assign new connection to peer socket object.
-    if (new_socket != invalid_socket)
-    {
-      socket_holder new_socket_holder(new_socket);
-      if (o->peer_endpoint_)
-        o->peer_endpoint_->resize(addrlen);
-      if (!o->peer_.assign(o->protocol_, new_socket, o->ec_))
-        new_socket_holder.release();
-    }
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_accept", o->ec_));
 
     return result;
   }
 
+  void do_assign()
+  {
+    if (new_socket_.get() != invalid_socket)
+    {
+      if (peer_endpoint_)
+        peer_endpoint_->resize(addrlen_);
+      peer_.assign(protocol_, new_socket_.get(), ec_);
+      if (!ec_)
+        new_socket_.release();
+    }
+  }
+
 private:
   socket_type socket_;
   socket_ops::state_type state_;
+  socket_holder new_socket_;
   Socket& peer_;
   Protocol protocol_;
   typename Protocol::endpoint* peer_endpoint_;
+  std::size_t addrlen_;
 };
 
 template <typename Socket, typename Protocol, typename Handler>
@@ -91,17 +99,23 @@ class reactive_socket_accept_op :
         protocol, peer_endpoint, &reactive_socket_accept_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
+
+    // On success, assign new connection to peer socket object.
+    if (owner)
+      o->do_assign();
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -119,7 +133,72 @@ class reactive_socket_accept_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
+      ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+};
+
+#if defined(ASIO_HAS_MOVE)
+
+template <typename Protocol, typename Handler>
+class reactive_socket_move_accept_op :
+  private Protocol::socket,
+  public reactive_socket_accept_op_base<typename Protocol::socket, Protocol>
+{
+public:
+  ASIO_DEFINE_HANDLER_PTR(reactive_socket_move_accept_op);
+
+  reactive_socket_move_accept_op(io_context& ioc, socket_type socket,
+      socket_ops::state_type state, const Protocol& protocol,
+      typename Protocol::endpoint* peer_endpoint, Handler& handler)
+    : Protocol::socket(ioc),
+      reactive_socket_accept_op_base<typename Protocol::socket, Protocol>(
+        socket, state, *this, protocol, peer_endpoint,
+        &reactive_socket_move_accept_op::do_complete),
+      handler_(ASIO_MOVE_CAST(Handler)(handler))
+  {
+    handler_work<Handler>::start(handler_);
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const asio::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    reactive_socket_move_accept_op* o(
+        static_cast<reactive_socket_move_accept_op*>(base));
+    ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
+
+    // On success, assign new connection to peer socket object.
+    if (owner)
+      o->do_assign();
+
+    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::move_binder2<Handler,
+      asio::error_code, typename Protocol::socket>
+        handler(0, ASIO_MOVE_CAST(Handler)(o->handler_), o->ec_,
+          ASIO_MOVE_CAST(typename Protocol::socket)(*o));
+    p.h = asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
@@ -128,6 +207,8 @@ class reactive_socket_accept_op :
   Handler handler_;
 };
 
+#endif // defined(ASIO_HAS_MOVE)
+
 } // namespace detail
 } // namespace asio
 
diff --git a/extern/include/asio/detail/reactive_socket_connect_op.hpp b/extern/include/asio/detail/reactive_socket_connect_op.hpp
index bd9146a5..76164b2a 100644
--- a/extern/include/asio/detail/reactive_socket_connect_op.hpp
+++ b/extern/include/asio/detail/reactive_socket_connect_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_connect_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 
@@ -37,12 +37,17 @@ class reactive_socket_connect_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     reactive_socket_connect_op_base* o(
         static_cast<reactive_socket_connect_op_base*>(base));
 
-    return socket_ops::non_blocking_connect(o->socket_, o->ec_);
+    status result = socket_ops::non_blocking_connect(
+        o->socket_, o->ec_) ? done : not_done;
+
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_connect", o->ec_));
+
+    return result;
   }
 
 private:
@@ -60,9 +65,10 @@ class reactive_socket_connect_op : public reactive_socket_connect_op_base
         &reactive_socket_connect_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
@@ -70,8 +76,9 @@ class reactive_socket_connect_op : public reactive_socket_connect_op_base
     reactive_socket_connect_op* o
       (static_cast<reactive_socket_connect_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -89,7 +96,7 @@ class reactive_socket_connect_op : public reactive_socket_connect_op_base
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      asio_handler_invoke_helpers::invoke(handler, handler);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/reactive_socket_recv_op.hpp b/extern/include/asio/detail/reactive_socket_recv_op.hpp
index 4a1e9da2..04bd266f 100644
--- a/extern/include/asio/detail/reactive_socket_recv_op.hpp
+++ b/extern/include/asio/detail/reactive_socket_recv_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 
@@ -43,7 +43,7 @@ class reactive_socket_recv_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     reactive_socket_recv_op_base* o(
         static_cast<reactive_socket_recv_op_base*>(base));
@@ -51,10 +51,20 @@ class reactive_socket_recv_op_base : public reactor_op
     buffer_sequence_adapter<asio::mutable_buffer,
         MutableBufferSequence> bufs(o->buffers_);
 
-    return socket_ops::non_blocking_recv(o->socket_,
+    status result = socket_ops::non_blocking_recv(o->socket_,
         bufs.buffers(), bufs.count(), o->flags_,
         (o->state_ & socket_ops::stream_oriented) != 0,
-        o->ec_, o->bytes_transferred_);
+        o->ec_, o->bytes_transferred_) ? done : not_done;
+
+    if (result == done)
+      if ((o->state_ & socket_ops::stream_oriented) != 0)
+        if (o->bytes_transferred_ == 0)
+          result = done_and_exhausted;
+
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_recv",
+          o->ec_, o->bytes_transferred_));
+
+    return result;
   }
 
 private:
@@ -78,17 +88,19 @@ class reactive_socket_recv_op :
         buffers, flags, &reactive_socket_recv_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -106,7 +118,7 @@ class reactive_socket_recv_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/reactive_socket_recvfrom_op.hpp b/extern/include/asio/detail/reactive_socket_recvfrom_op.hpp
index 1921071c..3d4fa4ca 100644
--- a/extern/include/asio/detail/reactive_socket_recvfrom_op.hpp
+++ b/extern/include/asio/detail/reactive_socket_recvfrom_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_recvfrom_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 
@@ -44,7 +44,7 @@ class reactive_socket_recvfrom_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     reactive_socket_recvfrom_op_base* o(
         static_cast<reactive_socket_recvfrom_op_base*>(base));
@@ -53,14 +53,17 @@ class reactive_socket_recvfrom_op_base : public reactor_op
         MutableBufferSequence> bufs(o->buffers_);
 
     std::size_t addr_len = o->sender_endpoint_.capacity();
-    bool result = socket_ops::non_blocking_recvfrom(o->socket_,
+    status result = socket_ops::non_blocking_recvfrom(o->socket_,
         bufs.buffers(), bufs.count(), o->flags_,
         o->sender_endpoint_.data(), &addr_len,
-        o->ec_, o->bytes_transferred_);
+        o->ec_, o->bytes_transferred_) ? done : not_done;
 
     if (result && !o->ec_)
       o->sender_endpoint_.resize(addr_len);
 
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_recvfrom",
+          o->ec_, o->bytes_transferred_));
+
     return result;
   }
 
@@ -87,9 +90,10 @@ class reactive_socket_recvfrom_op :
         &reactive_socket_recvfrom_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
@@ -97,8 +101,9 @@ class reactive_socket_recvfrom_op :
     reactive_socket_recvfrom_op* o(
         static_cast<reactive_socket_recvfrom_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -116,7 +121,7 @@ class reactive_socket_recvfrom_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/reactive_socket_recvmsg_op.hpp b/extern/include/asio/detail/reactive_socket_recvmsg_op.hpp
index a8c9df40..f4732747 100644
--- a/extern/include/asio/detail/reactive_socket_recvmsg_op.hpp
+++ b/extern/include/asio/detail/reactive_socket_recvmsg_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_recvmsg_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/socket_base.hpp"
@@ -44,7 +44,7 @@ class reactive_socket_recvmsg_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     reactive_socket_recvmsg_op_base* o(
         static_cast<reactive_socket_recvmsg_op_base*>(base));
@@ -52,10 +52,15 @@ class reactive_socket_recvmsg_op_base : public reactor_op
     buffer_sequence_adapter<asio::mutable_buffer,
         MutableBufferSequence> bufs(o->buffers_);
 
-    return socket_ops::non_blocking_recvmsg(o->socket_,
+    status result = socket_ops::non_blocking_recvmsg(o->socket_,
         bufs.buffers(), bufs.count(),
         o->in_flags_, o->out_flags_,
-        o->ec_, o->bytes_transferred_);
+        o->ec_, o->bytes_transferred_) ? done : not_done;
+
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_recvmsg",
+          o->ec_, o->bytes_transferred_));
+
+    return result;
   }
 
 private:
@@ -79,9 +84,10 @@ class reactive_socket_recvmsg_op :
         in_flags, out_flags, &reactive_socket_recvmsg_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
@@ -89,8 +95,9 @@ class reactive_socket_recvmsg_op :
     reactive_socket_recvmsg_op* o(
         static_cast<reactive_socket_recvmsg_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -108,7 +115,7 @@ class reactive_socket_recvmsg_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/reactive_socket_send_op.hpp b/extern/include/asio/detail/reactive_socket_send_op.hpp
index af0b6276..bd550d9c 100644
--- a/extern/include/asio/detail/reactive_socket_send_op.hpp
+++ b/extern/include/asio/detail/reactive_socket_send_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 
@@ -33,16 +33,17 @@ class reactive_socket_send_op_base : public reactor_op
 {
 public:
   reactive_socket_send_op_base(socket_type socket,
-      const ConstBufferSequence& buffers,
+      socket_ops::state_type state, const ConstBufferSequence& buffers,
       socket_base::message_flags flags, func_type complete_func)
     : reactor_op(&reactive_socket_send_op_base::do_perform, complete_func),
       socket_(socket),
+      state_(state),
       buffers_(buffers),
       flags_(flags)
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     reactive_socket_send_op_base* o(
         static_cast<reactive_socket_send_op_base*>(base));
@@ -50,13 +51,24 @@ class reactive_socket_send_op_base : public reactor_op
     buffer_sequence_adapter<asio::const_buffer,
         ConstBufferSequence> bufs(o->buffers_);
 
-    return socket_ops::non_blocking_send(o->socket_,
+    status result = socket_ops::non_blocking_send(o->socket_,
           bufs.buffers(), bufs.count(), o->flags_,
-          o->ec_, o->bytes_transferred_);
+          o->ec_, o->bytes_transferred_) ? done : not_done;
+
+    if (result == done)
+      if ((o->state_ & socket_ops::stream_oriented) != 0)
+        if (o->bytes_transferred_ < bufs.total_size())
+          result = done_and_exhausted;
+
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_send",
+          o->ec_, o->bytes_transferred_));
+
+    return result;
   }
 
 private:
   socket_type socket_;
+  socket_ops::state_type state_;
   ConstBufferSequence buffers_;
   socket_base::message_flags flags_;
 };
@@ -69,23 +81,25 @@ class reactive_socket_send_op :
   ASIO_DEFINE_HANDLER_PTR(reactive_socket_send_op);
 
   reactive_socket_send_op(socket_type socket,
-      const ConstBufferSequence& buffers,
+      socket_ops::state_type state, const ConstBufferSequence& buffers,
       socket_base::message_flags flags, Handler& handler)
     : reactive_socket_send_op_base<ConstBufferSequence>(socket,
-        buffers, flags, &reactive_socket_send_op::do_complete),
+        state, buffers, flags, &reactive_socket_send_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -103,7 +117,7 @@ class reactive_socket_send_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/reactive_socket_sendto_op.hpp b/extern/include/asio/detail/reactive_socket_sendto_op.hpp
index 28f7feb9..c97554d7 100644
--- a/extern/include/asio/detail/reactive_socket_sendto_op.hpp
+++ b/extern/include/asio/detail/reactive_socket_sendto_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_sendto_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,10 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 
@@ -43,7 +43,7 @@ class reactive_socket_sendto_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     reactive_socket_sendto_op_base* o(
         static_cast<reactive_socket_sendto_op_base*>(base));
@@ -51,10 +51,15 @@ class reactive_socket_sendto_op_base : public reactor_op
     buffer_sequence_adapter<asio::const_buffer,
         ConstBufferSequence> bufs(o->buffers_);
 
-    return socket_ops::non_blocking_sendto(o->socket_,
+    status result = socket_ops::non_blocking_sendto(o->socket_,
           bufs.buffers(), bufs.count(), o->flags_,
           o->destination_.data(), o->destination_.size(),
-          o->ec_, o->bytes_transferred_);
+          o->ec_, o->bytes_transferred_) ? done : not_done;
+
+    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_sendto",
+          o->ec_, o->bytes_transferred_));
+
+    return result;
   }
 
 private:
@@ -78,17 +83,19 @@ class reactive_socket_sendto_op :
         buffers, endpoint, flags, &reactive_socket_sendto_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -106,7 +113,7 @@ class reactive_socket_sendto_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/reactive_socket_service.hpp b/extern/include/asio/detail/reactive_socket_service.hpp
index 235fb4e9..15a4fdb5 100644
--- a/extern/include/asio/detail/reactive_socket_service.hpp
+++ b/extern/include/asio/detail/reactive_socket_service.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,10 +21,10 @@
 
 #include "asio/buffer.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/socket_base.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/reactive_null_buffers_op.hpp"
 #include "asio/detail/reactive_socket_accept_op.hpp"
@@ -45,6 +45,7 @@ namespace detail {
 
 template <typename Protocol>
 class reactive_socket_service :
+  public service_base<reactive_socket_service<Protocol> >,
   public reactive_socket_service_base
 {
 public:
@@ -72,11 +73,18 @@ class reactive_socket_service :
   };
 
   // Constructor.
-  reactive_socket_service(asio::io_service& io_service)
-    : reactive_socket_service_base(io_service)
+  reactive_socket_service(asio::io_context& io_context)
+    : service_base<reactive_socket_service<Protocol> >(io_context),
+      reactive_socket_service_base(io_context)
   {
   }
 
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown()
+  {
+    this->base_shutdown();
+  }
+
   // Move-construct a new socket implementation.
   void move_construct(implementation_type& impl,
       implementation_type& other_impl)
@@ -101,6 +109,7 @@ class reactive_socket_service :
   // Move-construct a new socket implementation from another protocol type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      reactive_socket_service<Protocol1>&,
       typename reactive_socket_service<
         Protocol1>::implementation_type& other_impl)
   {
@@ -194,6 +203,14 @@ class reactive_socket_service :
     return endpoint;
   }
 
+  // Disable sends or receives on the socket.
+  asio::error_code shutdown(base_implementation_type& impl,
+      socket_base::shutdown_type what, asio::error_code& ec)
+  {
+    socket_ops::shutdown(impl.socket_, what, ec);
+    return ec;
+  }
+
   // Send a datagram to the specified endpoint. Returns the number of bytes
   // sent.
   template <typename ConstBufferSequence>
@@ -215,7 +232,7 @@ class reactive_socket_service :
       asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
 
     return 0;
   }
@@ -235,11 +252,11 @@ class reactive_socket_service :
     typedef reactive_socket_sendto_op<ConstBufferSequence,
         endpoint_type, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_send_to"));
 
     start_op(impl, reactor::write_op, p.p, is_continuation, true, false);
     p.v = p.p = 0;
@@ -256,12 +273,11 @@ class reactive_socket_service :
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_send_to(null_buffers)"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_send_to(null_buffers)"));
 
     start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
@@ -295,7 +311,7 @@ class reactive_socket_service :
       asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
 
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
@@ -318,14 +334,13 @@ class reactive_socket_service :
     typedef reactive_socket_recvfrom_op<MutableBufferSequence,
         endpoint_type, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     int protocol = impl.protocol_.type();
     p.p = new (p.v) op(impl.socket_, protocol,
         buffers, sender_endpoint, flags, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_receive_from"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive_from"));
 
     start_op(impl,
         (flags & socket_base::message_out_of_band)
@@ -346,12 +361,11 @@ class reactive_socket_service :
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_receive_from(null_buffers)"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive_from(null_buffers)"));
 
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
@@ -385,15 +399,44 @@ class reactive_socket_service :
     {
       if (peer_endpoint)
         peer_endpoint->resize(addr_len);
-      if (!peer.assign(impl.protocol_, new_socket.get(), ec))
+      peer.assign(impl.protocol_, new_socket.get(), ec);
+      if (!ec)
         new_socket.release();
     }
 
     return ec;
   }
 
-  // Start an asynchronous accept. The peer and peer_endpoint objects
-  // must be valid until the accept's handler is invoked.
+#if defined(ASIO_HAS_MOVE)
+  // Accept a new connection.
+  typename Protocol::socket accept(implementation_type& impl,
+      io_context* peer_io_context, endpoint_type* peer_endpoint,
+      asio::error_code& ec)
+  {
+    typename Protocol::socket peer(
+        peer_io_context ? *peer_io_context : io_context_);
+
+    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
+    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
+          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
+          peer_endpoint ? &addr_len : 0, ec));
+
+    // On success, assign new connection to peer socket object.
+    if (new_socket.get() != invalid_socket)
+    {
+      if (peer_endpoint)
+        peer_endpoint->resize(addr_len);
+      peer.assign(impl.protocol_, new_socket.get(), ec);
+      if (!ec)
+        new_socket.release();
+    }
+
+    return peer;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  // Start an asynchronous accept. The peer and peer_endpoint objects must be
+  // valid until the accept's handler is invoked.
   template <typename Socket, typename Handler>
   void async_accept(implementation_type& impl, Socket& peer,
       endpoint_type* peer_endpoint, Handler& handler)
@@ -404,17 +447,43 @@ class reactive_socket_service :
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_accept_op<Socket, Protocol, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.socket_, impl.state_, peer,
         impl.protocol_, peer_endpoint, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_accept"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_accept"));
 
     start_accept_op(impl, p.p, is_continuation, peer.is_open());
     p.v = p.p = 0;
   }
 
+#if defined(ASIO_HAS_MOVE)
+  // Start an asynchronous accept. The peer_endpoint object must be valid until
+  // the accept's handler is invoked.
+  template <typename Handler>
+  void async_accept(implementation_type& impl,
+      asio::io_context* peer_io_context,
+      endpoint_type* peer_endpoint, Handler& handler)
+  {
+    bool is_continuation =
+      asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef reactive_socket_move_accept_op<Protocol, Handler> op;
+    typename op::ptr p = { asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(peer_io_context ? *peer_io_context : io_context_,
+        impl.socket_, impl.state_, impl.protocol_, peer_endpoint, handler);
+
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_accept"));
+
+    start_accept_op(impl, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   // Connect the socket to the specified endpoint.
   asio::error_code connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, asio::error_code& ec)
@@ -435,11 +504,11 @@ class reactive_socket_service :
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_connect_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.socket_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_connect"));
 
     start_connect_op(impl, p.p, is_continuation,
         peer_endpoint.data(), peer_endpoint.size());
diff --git a/extern/include/asio/detail/reactive_socket_service_base.hpp b/extern/include/asio/detail/reactive_socket_service_base.hpp
index b55053f8..ccd497e8 100644
--- a/extern/include/asio/detail/reactive_socket_service_base.hpp
+++ b/extern/include/asio/detail/reactive_socket_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,14 +22,15 @@
 
 #include "asio/buffer.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/socket_base.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactive_null_buffers_op.hpp"
 #include "asio/detail/reactive_socket_recv_op.hpp"
 #include "asio/detail/reactive_socket_recvmsg_op.hpp"
 #include "asio/detail/reactive_socket_send_op.hpp"
+#include "asio/detail/reactive_wait_op.hpp"
 #include "asio/detail/reactor.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_holder.hpp"
@@ -62,10 +63,10 @@ class reactive_socket_service_base
 
   // Constructor.
   ASIO_DECL reactive_socket_service_base(
-      asio::io_service& io_service);
+      asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void base_shutdown();
 
   // Construct a new socket implementation.
   ASIO_DECL void construct(base_implementation_type& impl);
@@ -92,6 +93,10 @@ class reactive_socket_service_base
   ASIO_DECL asio::error_code close(
       base_implementation_type& impl, asio::error_code& ec);
 
+  // Release ownership of the socket.
+  ASIO_DECL socket_type release(
+      base_implementation_type& impl, asio::error_code& ec);
+
   // Get the native socket representation.
   native_handle_type native_handle(base_implementation_type& impl)
   {
@@ -162,14 +167,71 @@ class reactive_socket_service_base
     return ec;
   }
 
-  // Disable sends or receives on the socket.
-  asio::error_code shutdown(base_implementation_type& impl,
-      socket_base::shutdown_type what, asio::error_code& ec)
+  // Wait for the socket to become ready to read, ready to write, or to have
+  // pending error conditions.
+  asio::error_code wait(base_implementation_type& impl,
+      socket_base::wait_type w, asio::error_code& ec)
   {
-    socket_ops::shutdown(impl.socket_, what, ec);
+    switch (w)
+    {
+    case socket_base::wait_read:
+      socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
+      break;
+    case socket_base::wait_write:
+      socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
+      break;
+    case socket_base::wait_error:
+      socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
+      break;
+    default:
+      ec = asio::error::invalid_argument;
+      break;
+    }
+
     return ec;
   }
 
+  // Asynchronously wait for the socket to become ready to read, ready to
+  // write, or to have pending error conditions.
+  template <typename Handler>
+  void async_wait(base_implementation_type& impl,
+      socket_base::wait_type w, Handler& handler)
+  {
+    bool is_continuation =
+      asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef reactive_wait_op<Handler> op;
+    typename op::ptr p = { asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(handler);
+
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_wait"));
+
+    int op_type;
+    switch (w)
+    {
+      case socket_base::wait_read:
+        op_type = reactor::read_op;
+        break;
+      case socket_base::wait_write:
+        op_type = reactor::write_op;
+        break;
+      case socket_base::wait_error:
+        op_type = reactor::except_op;
+        break;
+      default:
+        p.p->ec_ = asio::error::invalid_argument;
+        reactor_.post_immediate_completion(p.p, is_continuation);
+        p.v = p.p = 0;
+        return;
+    }
+
+    start_op(impl, op_type, p.p, is_continuation, false, false);
+    p.v = p.p = 0;
+  }
+
   // Send the given data to the peer.
   template <typename ConstBufferSequence>
   size_t send(base_implementation_type& impl,
@@ -188,7 +250,7 @@ class reactive_socket_service_base
       socket_base::message_flags, asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
 
     return 0;
   }
@@ -206,11 +268,11 @@ class reactive_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_send_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(impl.socket_, buffers, flags, handler);
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_send"));
 
     start_op(impl, reactor::write_op, p.p, is_continuation, true,
         ((impl.state_ & socket_ops::stream_oriented)
@@ -230,12 +292,11 @@ class reactive_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_send(null_buffers)"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_send(null_buffers)"));
 
     start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
@@ -259,7 +320,7 @@ class reactive_socket_service_base
       socket_base::message_flags, asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
 
     return 0;
   }
@@ -277,11 +338,11 @@ class reactive_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive"));
 
     start_op(impl,
         (flags & socket_base::message_out_of_band)
@@ -305,12 +366,11 @@ class reactive_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_receive(null_buffers)"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive(null_buffers)"));
 
     start_op(impl,
         (flags & socket_base::message_out_of_band)
@@ -340,7 +400,7 @@ class reactive_socket_service_base
       socket_base::message_flags& out_flags, asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
 
     // Clear out_flags, since we cannot give it any other sensible value when
     // performing a null_buffers operation.
@@ -362,12 +422,11 @@ class reactive_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recvmsg_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.socket_, buffers, in_flags, out_flags, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_receive_with_flags"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive_with_flags"));
 
     start_op(impl,
         (in_flags & socket_base::message_out_of_band)
@@ -389,12 +448,11 @@ class reactive_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl,
-          "async_receive_with_flags(null_buffers)"));
+    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
 
     // Clear out_flags, since we cannot give it any other sensible value when
     // performing a null_buffers operation.
@@ -431,6 +489,9 @@ class reactive_socket_service_base
       reactor_op* op, bool is_continuation,
       const socket_addr_type* addr, size_t addrlen);
 
+  // The io_context that owns this socket service.
+  io_context& io_context_;
+
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 };
diff --git a/extern/include/asio/detail/reactive_wait_op.hpp b/extern/include/asio/detail/reactive_wait_op.hpp
new file mode 100644
index 00000000..616d8b11
--- /dev/null
+++ b/extern/include/asio/detail/reactive_wait_op.hpp
@@ -0,0 +1,90 @@
+//
+// detail/reactive_wait_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_REACTIVE_WAIT_OP_HPP
+#define ASIO_DETAIL_REACTIVE_WAIT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/reactor_op.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Handler>
+class reactive_wait_op : public reactor_op
+{
+public:
+  ASIO_DEFINE_HANDLER_PTR(reactive_wait_op);
+
+  reactive_wait_op(Handler& handler)
+    : reactor_op(&reactive_wait_op::do_perform,
+        &reactive_wait_op::do_complete),
+      handler_(ASIO_MOVE_CAST(Handler)(handler))
+  {
+    handler_work<Handler>::start(handler_);
+  }
+
+  static status do_perform(reactor_op*)
+  {
+    return done;
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const asio::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    reactive_wait_op* o(static_cast<reactive_wait_op*>(base));
+    ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
+
+    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::binder1<Handler, asio::error_code>
+      handler(o->handler_, o->ec_);
+    p.h = asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      w.complete(handler, handler.handler_);
+      ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_REACTIVE_WAIT_OP_HPP
diff --git a/extern/include/asio/detail/reactor.hpp b/extern/include/asio/detail/reactor.hpp
index 29a51571..47502764 100644
--- a/extern/include/asio/detail/reactor.hpp
+++ b/extern/include/asio/detail/reactor.hpp
@@ -2,7 +2,7 @@
 // detail/reactor.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,7 +23,7 @@
 # include "asio/detail/kqueue_reactor.hpp"
 #elif defined(ASIO_HAS_DEV_POLL)
 # include "asio/detail/dev_poll_reactor.hpp"
-#elif defined(ASIO_WINDOWS_RUNTIME)
+#elif defined(ASIO_HAS_IOCP) || defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/null_reactor.hpp"
 #else
 # include "asio/detail/select_reactor.hpp"
diff --git a/extern/include/asio/detail/reactor_fwd.hpp b/extern/include/asio/detail/reactor_fwd.hpp
index 2b6076c2..a4555c3d 100644
--- a/extern/include/asio/detail/reactor_fwd.hpp
+++ b/extern/include/asio/detail/reactor_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/reactor_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,7 +20,7 @@
 namespace asio {
 namespace detail {
 
-#if defined(ASIO_WINDOWS_RUNTIME)
+#if defined(ASIO_HAS_IOCP) || defined(ASIO_WINDOWS_RUNTIME)
 typedef class null_reactor reactor;
 #elif defined(ASIO_HAS_IOCP)
 typedef class select_reactor reactor;
diff --git a/extern/include/asio/detail/reactor_op.hpp b/extern/include/asio/detail/reactor_op.hpp
index b339ffdd..faad1a77 100644
--- a/extern/include/asio/detail/reactor_op.hpp
+++ b/extern/include/asio/detail/reactor_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactor_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -33,14 +33,18 @@ class reactor_op
   // The number of bytes transferred, to be passed to the completion handler.
   std::size_t bytes_transferred_;
 
+  // Status returned by perform function. May be used to decide whether it is
+  // worth performing more operations on the descriptor immediately.
+  enum status { not_done, done, done_and_exhausted };
+
   // Perform the operation. Returns true if it is finished.
-  bool perform()
+  status perform()
   {
     return perform_func_(this);
   }
 
 protected:
-  typedef bool (*perform_func_type)(reactor_op*);
+  typedef status (*perform_func_type)(reactor_op*);
 
   reactor_op(perform_func_type perform_func, func_type complete_func)
     : operation(complete_func),
diff --git a/extern/include/asio/detail/reactor_op_queue.hpp b/extern/include/asio/detail/reactor_op_queue.hpp
index efeacf71..898f31d1 100644
--- a/extern/include/asio/detail/reactor_op_queue.hpp
+++ b/extern/include/asio/detail/reactor_op_queue.hpp
@@ -2,7 +2,7 @@
 // detail/reactor_op_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/recycling_allocator.hpp b/extern/include/asio/detail/recycling_allocator.hpp
new file mode 100644
index 00000000..964af1da
--- /dev/null
+++ b/extern/include/asio/detail/recycling_allocator.hpp
@@ -0,0 +1,104 @@
+//
+// detail/recycling_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP
+#define ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/thread_context.hpp"
+#include "asio/detail/thread_info_base.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+class recycling_allocator
+{
+public:
+  typedef T value_type;
+
+  template <typename U>
+  struct rebind
+  {
+    typedef recycling_allocator<U> other;
+  };
+
+  recycling_allocator()
+  {
+  }
+
+  template <typename U>
+  recycling_allocator(const recycling_allocator<U>&)
+  {
+  }
+
+  T* allocate(std::size_t n)
+  {
+    typedef thread_context::thread_call_stack call_stack;
+    void* p = thread_info_base::allocate(call_stack::top(), sizeof(T) * n);
+    return static_cast<T*>(p);
+  }
+
+  void deallocate(T* p, std::size_t n)
+  {
+    typedef thread_context::thread_call_stack call_stack;
+    thread_info_base::deallocate(call_stack::top(), p, sizeof(T) * n);
+  }
+};
+
+template <>
+class recycling_allocator<void>
+{
+public:
+  typedef void value_type;
+
+  template <typename U>
+  struct rebind
+  {
+    typedef recycling_allocator<U> other;
+  };
+
+  recycling_allocator()
+  {
+  }
+
+  template <typename U>
+  recycling_allocator(const recycling_allocator<U>&)
+  {
+  }
+};
+
+template <typename Allocator>
+struct get_recycling_allocator
+{
+  typedef Allocator type;
+  static type get(const Allocator& a) { return a; }
+};
+
+template <typename T>
+struct get_recycling_allocator<std::allocator<T> >
+{
+  typedef recycling_allocator<T> type;
+  static type get(const std::allocator<T>&) { return type(); }
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP
diff --git a/extern/include/asio/detail/regex_fwd.hpp b/extern/include/asio/detail/regex_fwd.hpp
index af825c61..dcf7d06e 100644
--- a/extern/include/asio/detail/regex_fwd.hpp
+++ b/extern/include/asio/detail/regex_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/regex_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/resolve_endpoint_op.hpp b/extern/include/asio/detail/resolve_endpoint_op.hpp
index 75897a03..8eee2f98 100644
--- a/extern/include/asio/detail/resolve_endpoint_op.hpp
+++ b/extern/include/asio/detail/resolve_endpoint_op.hpp
@@ -2,7 +2,7 @@
 // detail/resolve_endpoint_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,14 +17,14 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/io_context.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
-#include "asio/detail/operation.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/resolve_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -33,35 +33,37 @@ namespace asio {
 namespace detail {
 
 template <typename Protocol, typename Handler>
-class resolve_endpoint_op : public operation
+class resolve_endpoint_op : public resolve_op
 {
 public:
   ASIO_DEFINE_HANDLER_PTR(resolve_endpoint_op);
 
   typedef typename Protocol::endpoint endpoint_type;
-  typedef asio::ip::basic_resolver_iterator<Protocol> iterator_type;
+  typedef asio::ip::basic_resolver_results<Protocol> results_type;
 
   resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
-      const endpoint_type& endpoint, io_service_impl& ios, Handler& handler)
-    : operation(&resolve_endpoint_op::do_complete),
+      const endpoint_type& endpoint, io_context_impl& ioc, Handler& handler)
+    : resolve_op(&resolve_endpoint_op::do_complete),
       cancel_token_(cancel_token),
       endpoint_(endpoint),
-      io_service_impl_(ios),
+      io_context_impl_(ioc),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the operation object.
     resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    if (owner && owner != &o->io_service_impl_)
+    if (owner && owner != &o->io_context_impl_)
     {
-      // The operation is being run on the worker io_service. Time to perform
+      // The operation is being run on the worker io_context. Time to perform
       // the resolver operation.
     
       // Perform the blocking endpoint resolution operation.
@@ -70,18 +72,18 @@ class resolve_endpoint_op : public operation
       socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
           o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV,
           o->endpoint_.protocol().type(), o->ec_);
-      o->iter_ = iterator_type::create(o->endpoint_, host_name, service_name);
+      o->results_ = results_type::create(o->endpoint_, host_name, service_name);
 
-      // Pass operation back to main io_service for completion.
-      o->io_service_impl_.post_deferred_completion(o);
+      // Pass operation back to main io_context for completion.
+      o->io_context_impl_.post_deferred_completion(o);
       p.v = p.p = 0;
     }
     else
     {
-      // The operation has been returned to the main io_service. The completion
+      // The operation has been returned to the main io_context. The completion
       // handler is ready to be delivered.
 
-      ASIO_HANDLER_COMPLETION((o));
+      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,
@@ -89,8 +91,8 @@ class resolve_endpoint_op : public operation
       // 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, asio::error_code, iterator_type>
-        handler(o->handler_, o->ec_, o->iter_);
+      detail::binder2<Handler, asio::error_code, results_type>
+        handler(o->handler_, o->ec_, o->results_);
       p.h = asio::detail::addressof(handler.handler_);
       p.reset();
 
@@ -98,7 +100,7 @@ class resolve_endpoint_op : public operation
       {
         fenced_block b(fenced_block::half);
         ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-        asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+        w.complete(handler, handler.handler_);
         ASIO_HANDLER_INVOCATION_END;
       }
     }
@@ -107,10 +109,9 @@ class resolve_endpoint_op : public operation
 private:
   socket_ops::weak_cancel_token_type cancel_token_;
   endpoint_type endpoint_;
-  io_service_impl& io_service_impl_;
+  io_context_impl& io_context_impl_;
   Handler handler_;
-  asio::error_code ec_;
-  iterator_type iter_;
+  results_type results_;
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/resolve_op.hpp b/extern/include/asio/detail/resolve_op.hpp
index 0492fcd9..a528aa82 100644
--- a/extern/include/asio/detail/resolve_op.hpp
+++ b/extern/include/asio/detail/resolve_op.hpp
@@ -2,7 +2,7 @@
 // detail/resolve_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,110 +17,24 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/detail/addressof.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
 #include "asio/detail/operation.hpp"
-#include "asio/detail/socket_ops.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-template <typename Protocol, typename Handler>
 class resolve_op : public operation
 {
 public:
-  ASIO_DEFINE_HANDLER_PTR(resolve_op);
-
-  typedef asio::ip::basic_resolver_query<Protocol> query_type;
-  typedef 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)
-    : operation(&resolve_op::do_complete),
-      cancel_token_(cancel_token),
-      query_(query),
-      io_service_impl_(ios),
-      handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      addrinfo_(0)
-  {
-  }
+  // The error code to be passed to the completion handler.
+  asio::error_code ec_;
 
-  ~resolve_op()
+protected:
+  resolve_op(func_type complete_func)
+    : operation(complete_func)
   {
-    if (addrinfo_)
-      socket_ops::freeaddrinfo(addrinfo_);
   }
-
-  static void do_complete(io_service_impl* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the operation object.
-    resolve_op* o(static_cast<resolve_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    if (owner && owner != &o->io_service_impl_)
-    {
-      // The operation is being run on the worker io_service. Time to perform
-      // the resolver operation.
-    
-      // Perform the blocking host resolution operation.
-      socket_ops::background_getaddrinfo(o->cancel_token_,
-          o->query_.host_name().c_str(), o->query_.service_name().c_str(),
-          o->query_.hints(), &o->addrinfo_, o->ec_);
-
-      // Pass operation back to main io_service for completion.
-      o->io_service_impl_.post_deferred_completion(o);
-      p.v = p.p = 0;
-    }
-    else
-    {
-      // The operation has been returned to the main io_service. The completion
-      // handler is ready to be delivered.
-
-      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, asio::error_code, iterator_type>
-        handler(o->handler_, o->ec_, iterator_type());
-      p.h = asio::detail::addressof(handler.handler_);
-      if (o->addrinfo_)
-      {
-        handler.arg2_ = iterator_type::create(o->addrinfo_,
-            o->query_.host_name(), o->query_.service_name());
-      }
-      p.reset();
-
-      if (owner)
-      {
-        fenced_block b(fenced_block::half);
-        ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-        asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-        ASIO_HANDLER_INVOCATION_END;
-      }
-    }
-  }
-
-private:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  query_type query_;
-  io_service_impl& io_service_impl_;
-  Handler handler_;
-  asio::error_code ec_;
-  asio::detail::addrinfo_type* addrinfo_;
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/resolve_query_op.hpp b/extern/include/asio/detail/resolve_query_op.hpp
new file mode 100644
index 00000000..0ec5a321
--- /dev/null
+++ b/extern/include/asio/detail/resolve_query_op.hpp
@@ -0,0 +1,134 @@
+//
+// detail/resolve_query_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_RESOLVE_QUERY_OP_HPP
+#define ASIO_DETAIL_RESOLVE_QUERY_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/error.hpp"
+#include "asio/io_context.hpp"
+#include "asio/ip/basic_resolver_query.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
+#include "asio/detail/bind_handler.hpp"
+#include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/resolve_op.hpp"
+#include "asio/detail/socket_ops.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Protocol, typename Handler>
+class resolve_query_op : public resolve_op
+{
+public:
+  ASIO_DEFINE_HANDLER_PTR(resolve_query_op);
+
+  typedef asio::ip::basic_resolver_query<Protocol> query_type;
+  typedef asio::ip::basic_resolver_results<Protocol> results_type;
+
+  resolve_query_op(socket_ops::weak_cancel_token_type cancel_token,
+      const query_type& query, io_context_impl& ioc, Handler& handler)
+    : resolve_op(&resolve_query_op::do_complete),
+      cancel_token_(cancel_token),
+      query_(query),
+      io_context_impl_(ioc),
+      handler_(ASIO_MOVE_CAST(Handler)(handler)),
+      addrinfo_(0)
+  {
+    handler_work<Handler>::start(handler_);
+  }
+
+  ~resolve_query_op()
+  {
+    if (addrinfo_)
+      socket_ops::freeaddrinfo(addrinfo_);
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const asio::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the operation object.
+    resolve_query_op* o(static_cast<resolve_query_op*>(base));
+    ptr p = { asio::detail::addressof(o->handler_), o, o };
+
+    if (owner && owner != &o->io_context_impl_)
+    {
+      // The operation is being run on the worker io_context. Time to perform
+      // the resolver operation.
+    
+      // Perform the blocking host resolution operation.
+      socket_ops::background_getaddrinfo(o->cancel_token_,
+          o->query_.host_name().c_str(), o->query_.service_name().c_str(),
+          o->query_.hints(), &o->addrinfo_, o->ec_);
+
+      // Pass operation back to main io_context for completion.
+      o->io_context_impl_.post_deferred_completion(o);
+      p.v = p.p = 0;
+    }
+    else
+    {
+      // The operation has been returned to the main io_context. The completion
+      // handler is ready to be delivered.
+
+      // Take ownership of the operation's outstanding work.
+      handler_work<Handler> w(o->handler_);
+
+      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, asio::error_code, results_type>
+        handler(o->handler_, o->ec_, results_type());
+      p.h = asio::detail::addressof(handler.handler_);
+      if (o->addrinfo_)
+      {
+        handler.arg2_ = results_type::create(o->addrinfo_,
+            o->query_.host_name(), o->query_.service_name());
+      }
+      p.reset();
+
+      if (owner)
+      {
+        fenced_block b(fenced_block::half);
+        ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+        w.complete(handler, handler.handler_);
+        ASIO_HANDLER_INVOCATION_END;
+      }
+    }
+  }
+
+private:
+  socket_ops::weak_cancel_token_type cancel_token_;
+  query_type query_;
+  io_context_impl& io_context_impl_;
+  Handler handler_;
+  asio::detail::addrinfo_type* addrinfo_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_RESOLVE_QUERY_OP_HPP
diff --git a/extern/include/asio/detail/resolver_service.hpp b/extern/include/asio/detail/resolver_service.hpp
index 7395dfe6..11a94d13 100644
--- a/extern/include/asio/detail/resolver_service.hpp
+++ b/extern/include/asio/detail/resolver_service.hpp
@@ -2,7 +2,7 @@
 // detail/resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,11 +19,12 @@
 
 #if !defined(ASIO_WINDOWS_RUNTIME)
 
-#include "asio/ip/basic_resolver_iterator.hpp"
 #include "asio/ip/basic_resolver_query.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
+#include "asio/detail/concurrency_hint.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/resolve_endpoint_op.hpp"
-#include "asio/detail/resolve_op.hpp"
+#include "asio/detail/resolve_query_op.hpp"
 #include "asio/detail/resolver_service_base.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -32,7 +33,9 @@ namespace asio {
 namespace detail {
 
 template <typename Protocol>
-class resolver_service : public resolver_service_base
+class resolver_service :
+  public service_base<resolver_service<Protocol> >,
+  public resolver_service_base
 {
 public:
   // The implementation type of the resolver. A cancellation token is used to
@@ -45,17 +48,30 @@ class resolver_service : public resolver_service_base
   // The query type.
   typedef asio::ip::basic_resolver_query<Protocol> query_type;
 
-  // The iterator type.
-  typedef asio::ip::basic_resolver_iterator<Protocol> iterator_type;
+  // The results type.
+  typedef asio::ip::basic_resolver_results<Protocol> results_type;
 
   // Constructor.
-  resolver_service(asio::io_service& io_service)
-    : resolver_service_base(io_service)
+  resolver_service(asio::io_context& io_context)
+    : service_base<resolver_service<Protocol> >(io_context),
+      resolver_service_base(io_context)
   {
   }
 
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown()
+  {
+    this->base_shutdown();
+  }
+
+  // Perform any fork-related housekeeping.
+  void notify_fork(asio::io_context::fork_event fork_ev)
+  {
+    this->base_notify_fork(fork_ev);
+  }
+
   // Resolve a query to a list of entries.
-  iterator_type resolve(implementation_type&, const query_type& query,
+  results_type resolve(implementation_type&, const query_type& query,
       asio::error_code& ec)
   {
     asio::detail::addrinfo_type* address_info = 0;
@@ -64,7 +80,7 @@ class resolver_service : public resolver_service_base
         query.service_name().c_str(), query.hints(), &address_info, ec);
     auto_addrinfo auto_address_info(address_info);
 
-    return ec ? iterator_type() : iterator_type::create(
+    return ec ? results_type() : results_type::create(
         address_info, query.host_name(), query.service_name());
   }
 
@@ -74,20 +90,20 @@ class resolver_service : public resolver_service_base
       const query_type& query, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
-    typedef resolve_op<Protocol, Handler> op;
+    typedef resolve_query_op<Protocol, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(impl, query, io_service_impl_, handler);
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(impl, query, io_context_impl_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+    ASIO_HANDLER_CREATION((io_context_impl_.context(),
+          *p.p, "resolver", &impl, 0, "async_resolve"));
 
     start_resolve_op(p.p);
     p.v = p.p = 0;
   }
 
   // Resolve an endpoint to a list of entries.
-  iterator_type resolve(implementation_type&,
+  results_type resolve(implementation_type&,
       const endpoint_type& endpoint, asio::error_code& ec)
   {
     char host_name[NI_MAXHOST];
@@ -96,7 +112,7 @@ class resolver_service : public resolver_service_base
         host_name, NI_MAXHOST, service_name, NI_MAXSERV,
         endpoint.protocol().type(), ec);
 
-    return ec ? iterator_type() : iterator_type::create(
+    return ec ? results_type() : results_type::create(
         endpoint, host_name, service_name);
   }
 
@@ -108,11 +124,11 @@ class resolver_service : public resolver_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef resolve_endpoint_op<Protocol, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(impl, endpoint, io_service_impl_, handler);
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(impl, endpoint, io_context_impl_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+    ASIO_HANDLER_CREATION((io_context_impl_.context(),
+          *p.p, "resolver", &impl, 0, "async_resolve"));
 
     start_resolve_op(p.p);
     p.v = p.p = 0;
diff --git a/extern/include/asio/detail/resolver_service_base.hpp b/extern/include/asio/detail/resolver_service_base.hpp
index 221ae91a..10a79224 100644
--- a/extern/include/asio/detail/resolver_service_base.hpp
+++ b/extern/include/asio/detail/resolver_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/resolver_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,10 +17,11 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/executor_work_guard.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/noncopyable.hpp"
-#include "asio/detail/operation.hpp"
+#include "asio/detail/resolve_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/detail/socket_types.hpp"
 #include "asio/detail/scoped_ptr.hpp"
@@ -39,17 +40,17 @@ class resolver_service_base
   typedef socket_ops::shared_cancel_token_type implementation_type;
 
   // Constructor.
-  ASIO_DECL resolver_service_base(asio::io_service& io_service);
+  ASIO_DECL resolver_service_base(asio::io_context& io_context);
 
   // Destructor.
   ASIO_DECL ~resolver_service_base();
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void base_shutdown();
 
   // Perform any fork-related housekeeping.
-  ASIO_DECL void fork_service(
-      asio::io_service::fork_event fork_ev);
+  ASIO_DECL void base_notify_fork(
+      asio::io_context::fork_event fork_ev);
 
   // Construct a new resolver implementation.
   ASIO_DECL void construct(implementation_type& impl);
@@ -57,12 +58,21 @@ class resolver_service_base
   // Destroy a resolver implementation.
   ASIO_DECL void destroy(implementation_type&);
 
+  // Move-construct a new resolver implementation.
+  ASIO_DECL void move_construct(implementation_type& impl,
+      implementation_type& other_impl);
+
+  // Move-assign from another resolver implementation.
+  ASIO_DECL void move_assign(implementation_type& impl,
+      resolver_service_base& other_service,
+      implementation_type& other_impl);
+
   // Cancel pending asynchronous operations.
   ASIO_DECL void cancel(implementation_type& impl);
 
 protected:
   // Helper function to start an asynchronous resolve operation.
-  ASIO_DECL void start_resolve_op(operation* op);
+  ASIO_DECL void start_resolve_op(resolve_op* op);
 
 #if !defined(ASIO_WINDOWS_RUNTIME)
   // Helper class to perform exception-safe cleanup of addrinfo objects.
@@ -91,29 +101,30 @@ class resolver_service_base
   };
 #endif // !defined(ASIO_WINDOWS_RUNTIME)
 
-  // Helper class to run the work io_service in a thread.
-  class work_io_service_runner;
+  // Helper class to run the work io_context in a thread.
+  class work_io_context_runner;
 
   // Start the work thread if it's not already running.
   ASIO_DECL void start_work_thread();
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_impl_;
+  // The io_context implementation used to post completions.
+  io_context_impl& io_context_impl_;
 
 private:
   // Mutex to protect access to internal data.
   asio::detail::mutex mutex_;
 
-  // Private io_service used for performing asynchronous host resolution.
-  asio::detail::scoped_ptr<asio::io_service> work_io_service_;
+  // Private io_context used for performing asynchronous host resolution.
+  asio::detail::scoped_ptr<asio::io_context> work_io_context_;
 
-  // The work io_service implementation used to post completions.
-  io_service_impl& work_io_service_impl_;
+  // The work io_context implementation used to post completions.
+  io_context_impl& work_io_context_impl_;
 
-  // Work for the private io_service to perform.
-  asio::detail::scoped_ptr<asio::io_service::work> work_;
+  // Work for the private io_context to perform.
+  asio::executor_work_guard<
+      asio::io_context::executor_type> work_;
 
-  // Thread used for running the work io_service's run loop.
+  // Thread used for running the work io_context's run loop.
   asio::detail::scoped_ptr<asio::detail::thread> work_thread_;
 };
 
diff --git a/extern/include/asio/detail/task_io_service.hpp b/extern/include/asio/detail/scheduler.hpp
similarity index 68%
rename from extern/include/asio/detail/task_io_service.hpp
rename to extern/include/asio/detail/scheduler.hpp
index c0d593c3..10c29b7e 100644
--- a/extern/include/asio/detail/task_io_service.hpp
+++ b/extern/include/asio/detail/scheduler.hpp
@@ -1,15 +1,15 @@
 //
-// detail/task_io_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+// detail/scheduler.hpp
+// ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_TASK_IO_SERVICE_HPP
-#define ASIO_DETAIL_TASK_IO_SERVICE_HPP
+#ifndef ASIO_DETAIL_SCHEDULER_HPP
+#define ASIO_DETAIL_SCHEDULER_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,38 +17,37 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_HAS_IOCP)
-
 #include "asio/error_code.hpp"
-#include "asio/io_service.hpp"
+#include "asio/execution_context.hpp"
 #include "asio/detail/atomic_count.hpp"
-#include "asio/detail/call_stack.hpp"
-#include "asio/detail/event.hpp"
-#include "asio/detail/mutex.hpp"
+#include "asio/detail/conditionally_enabled_event.hpp"
+#include "asio/detail/conditionally_enabled_mutex.hpp"
 #include "asio/detail/op_queue.hpp"
 #include "asio/detail/reactor_fwd.hpp"
-#include "asio/detail/task_io_service_operation.hpp"
+#include "asio/detail/scheduler_operation.hpp"
+#include "asio/detail/thread_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-struct task_io_service_thread_info;
+struct scheduler_thread_info;
 
-class task_io_service
-  : public asio::detail::service_base<task_io_service>
+class scheduler
+  : public execution_context_service_base<scheduler>,
+    public thread_context
 {
 public:
-  typedef task_io_service_operation operation;
+  typedef scheduler_operation operation;
 
   // Constructor. Specifies the number of concurrent threads that are likely to
-  // run the io_service. If set to 1 certain optimisation are performed.
-  ASIO_DECL task_io_service(asio::io_service& io_service,
-      std::size_t concurrency_hint = 0);
+  // run the scheduler. If set to 1 certain optimisation are performed.
+  ASIO_DECL scheduler(asio::execution_context& ctx,
+      int concurrency_hint = 0);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Initialise the task, if required.
   ASIO_DECL void init_task();
@@ -59,6 +58,10 @@ class task_io_service
   // Run until interrupted or one operation is performed.
   ASIO_DECL std::size_t run_one(asio::error_code& ec);
 
+  // Run until timeout, interrupted, or one operation is performed.
+  ASIO_DECL std::size_t wait_one(
+      long usec, asio::error_code& ec);
+
   // Poll for operations without blocking.
   ASIO_DECL std::size_t poll(asio::error_code& ec);
 
@@ -68,11 +71,11 @@ class task_io_service
   // Interrupt the event processing loop.
   ASIO_DECL void stop();
 
-  // Determine whether the io_service is stopped.
+  // Determine whether the scheduler is stopped.
   ASIO_DECL bool stopped() const;
 
-  // Reset in preparation for a subsequent run invocation.
-  ASIO_DECL void reset();
+  // Restart in preparation for a subsequent run invocation.
+  ASIO_DECL void restart();
 
   // Notify that some work has started.
   void work_started()
@@ -80,6 +83,10 @@ class task_io_service
     ++outstanding_work_;
   }
 
+  // Used to compensate for a forthcoming work_finished call. Must be called
+  // from within a scheduler-owned thread.
+  ASIO_DECL void compensating_work_started();
+
   // Notify that some work has finished.
   void work_finished()
   {
@@ -93,14 +100,6 @@ class task_io_service
     return thread_call_stack::contains(this) != 0;
   }
 
-  // Request invocation of the given handler.
-  template <typename Handler>
-  void dispatch(Handler& handler);
-
-  // Request invocation of the given handler and return immediately.
-  template <typename Handler>
-  void post(Handler& handler);
-
   // Request invocation of the given operation and return immediately. Assumes
   // that work_started() has not yet been called for the operation.
   ASIO_DECL void post_immediate_completion(
@@ -114,22 +113,38 @@ class task_io_service
   // that work_started() was previously called for each operation.
   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.
+  // Enqueue the given operation following a failed attempt to dispatch the
+  // operation for immediate invocation.
+  ASIO_DECL void do_dispatch(operation* op);
+
+  // Process unfinished operations as part of a shutdownoperation. Assumes that
+  // work_started() was previously called for the operations.
   ASIO_DECL void abandon_operations(op_queue<operation>& ops);
 
+  // Get the concurrency hint that was used to initialise the scheduler.
+  int concurrency_hint() const
+  {
+    return concurrency_hint_;
+  }
+
 private:
-  // Structure containing thread-specific data.
-  typedef task_io_service_thread_info thread_info;
+  // The mutex type used by this scheduler.
+  typedef conditionally_enabled_mutex mutex;
 
-  // Enqueue the given operation following a failed attempt to dispatch the
-  // operation for immediate invocation.
-  ASIO_DECL void do_dispatch(operation* op);
+  // The event type used by this scheduler.
+  typedef conditionally_enabled_event event;
+
+  // Structure containing thread-specific data.
+  typedef scheduler_thread_info thread_info;
 
   // Run at most one operation. May block.
   ASIO_DECL std::size_t do_run_one(mutex::scoped_lock& lock,
       thread_info& this_thread, const asio::error_code& ec);
 
+  // Run at most one operation with a timeout. May block.
+  ASIO_DECL std::size_t do_wait_one(mutex::scoped_lock& lock,
+      thread_info& this_thread, long usec, const asio::error_code& ec);
+
   // Poll for at most one operation.
   ASIO_DECL std::size_t do_poll_one(mutex::scoped_lock& lock,
       thread_info& this_thread, const asio::error_code& ec);
@@ -182,8 +197,8 @@ class task_io_service
   // Flag to indicate that the dispatcher has been shut down.
   bool shutdown_;
 
-  // Per-thread call stack to track the state of each thread in the io_service.
-  typedef call_stack<task_io_service, thread_info> thread_call_stack;
+  // The concurrency hint used to initialise the scheduler.
+  const int concurrency_hint_;
 };
 
 } // namespace detail
@@ -191,11 +206,8 @@ class task_io_service
 
 #include "asio/detail/pop_options.hpp"
 
-#include "asio/detail/impl/task_io_service.hpp"
 #if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/task_io_service.ipp"
+# include "asio/detail/impl/scheduler.ipp"
 #endif // defined(ASIO_HEADER_ONLY)
 
-#endif // !defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_TASK_IO_SERVICE_HPP
+#endif // ASIO_DETAIL_SCHEDULER_HPP
diff --git a/extern/include/asio/detail/task_io_service_operation.hpp b/extern/include/asio/detail/scheduler_operation.hpp
similarity index 59%
rename from extern/include/asio/detail/task_io_service_operation.hpp
rename to extern/include/asio/detail/scheduler_operation.hpp
index 08b7867b..1c2ce02e 100644
--- a/extern/include/asio/detail/task_io_service_operation.hpp
+++ b/extern/include/asio/detail/scheduler_operation.hpp
@@ -1,15 +1,15 @@
 //
-// detail/task_io_service_operation.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// detail/scheduler_operation.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
-#define ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
+#ifndef ASIO_DETAIL_SCHEDULER_OPERATION_HPP
+#define ASIO_DETAIL_SCHEDULER_OPERATION_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -24,17 +24,19 @@
 namespace asio {
 namespace detail {
 
-class task_io_service;
+class scheduler;
 
 // Base class for all operations. A function pointer is used instead of virtual
 // functions to avoid the associated overhead.
-class task_io_service_operation ASIO_INHERIT_TRACKED_HANDLER
+class scheduler_operation ASIO_INHERIT_TRACKED_HANDLER
 {
 public:
-  void complete(task_io_service& owner,
-      const asio::error_code& ec, std::size_t bytes_transferred)
+  typedef scheduler_operation operation_type;
+
+  void complete(void* owner, const asio::error_code& ec,
+      std::size_t bytes_transferred)
   {
-    func_(&owner, this, ec, bytes_transferred);
+    func_(owner, this, ec, bytes_transferred);
   }
 
   void destroy()
@@ -43,11 +45,11 @@ class task_io_service_operation ASIO_INHERIT_TRACKED_HANDLER
   }
 
 protected:
-  typedef void (*func_type)(task_io_service*,
-      task_io_service_operation*,
+  typedef void (*func_type)(void*,
+      scheduler_operation*,
       const asio::error_code&, std::size_t);
 
-  task_io_service_operation(func_type func)
+  scheduler_operation(func_type func)
     : next_(0),
       func_(func),
       task_result_(0)
@@ -55,16 +57,16 @@ class task_io_service_operation ASIO_INHERIT_TRACKED_HANDLER
   }
 
   // Prevents deletion through this type.
-  ~task_io_service_operation()
+  ~scheduler_operation()
   {
   }
 
 private:
   friend class op_queue_access;
-  task_io_service_operation* next_;
+  scheduler_operation* next_;
   func_type func_;
 protected:
-  friend class task_io_service;
+  friend class scheduler;
   unsigned int task_result_; // Passed into bytes transferred.
 };
 
@@ -73,4 +75,4 @@ class task_io_service_operation ASIO_INHERIT_TRACKED_HANDLER
 
 #include "asio/detail/pop_options.hpp"
 
-#endif // ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
+#endif // ASIO_DETAIL_SCHEDULER_OPERATION_HPP
diff --git a/extern/include/asio/detail/task_io_service_thread_info.hpp b/extern/include/asio/detail/scheduler_thread_info.hpp
similarity index 54%
rename from extern/include/asio/detail/task_io_service_thread_info.hpp
rename to extern/include/asio/detail/scheduler_thread_info.hpp
index a1b5cf04..2ffe013b 100644
--- a/extern/include/asio/detail/task_io_service_thread_info.hpp
+++ b/extern/include/asio/detail/scheduler_thread_info.hpp
@@ -1,15 +1,15 @@
 //
-// detail/task_io_service_thread_info.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// detail/scheduler_thread_info.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
-#define ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
+#ifndef ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP
+#define ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -23,12 +23,12 @@
 namespace asio {
 namespace detail {
 
-class task_io_service;
-class task_io_service_operation;
+class scheduler;
+class scheduler_operation;
 
-struct task_io_service_thread_info : public thread_info_base
+struct scheduler_thread_info : public thread_info_base
 {
-  op_queue<task_io_service_operation> private_op_queue;
+  op_queue<scheduler_operation> private_op_queue;
   long private_outstanding_work;
 };
 
@@ -37,4 +37,4 @@ struct task_io_service_thread_info : public thread_info_base
 
 #include "asio/detail/pop_options.hpp"
 
-#endif // ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
+#endif // ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP
diff --git a/extern/include/asio/detail/scoped_lock.hpp b/extern/include/asio/detail/scoped_lock.hpp
index 27d6c8fd..6cbce381 100644
--- a/extern/include/asio/detail/scoped_lock.hpp
+++ b/extern/include/asio/detail/scoped_lock.hpp
@@ -2,7 +2,7 @@
 // detail/scoped_lock.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/scoped_ptr.hpp b/extern/include/asio/detail/scoped_ptr.hpp
index 23aa0ce6..3449c53b 100644
--- a/extern/include/asio/detail/scoped_ptr.hpp
+++ b/extern/include/asio/detail/scoped_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/scoped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -63,6 +63,14 @@ class scoped_ptr
     p_ = p;
   }
 
+  // Release ownership of the pointer.
+  T* release()
+  {
+    T* tmp = p_;
+    p_ = 0;
+    return tmp;
+  }
+
 private:
   // Disallow copying and assignment.
   scoped_ptr(const scoped_ptr&);
diff --git a/extern/include/asio/detail/select_interrupter.hpp b/extern/include/asio/detail/select_interrupter.hpp
index 4db8350d..1a075991 100644
--- a/extern/include/asio/detail/select_interrupter.hpp
+++ b/extern/include/asio/detail/select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/select_reactor.hpp b/extern/include/asio/detail/select_reactor.hpp
index a6c0cc55..09965492 100644
--- a/extern/include/asio/detail/select_reactor.hpp
+++ b/extern/include/asio/detail/select_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/select_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -35,7 +35,7 @@
 #include "asio/detail/timer_queue_base.hpp"
 #include "asio/detail/timer_queue_set.hpp"
 #include "asio/detail/wait_op.hpp"
-#include "asio/io_service.hpp"
+#include "asio/execution_context.hpp"
 
 #if defined(ASIO_HAS_IOCP)
 # include "asio/detail/thread.hpp"
@@ -47,7 +47,7 @@ namespace asio {
 namespace detail {
 
 class select_reactor
-  : public asio::detail::service_base<select_reactor>
+  : public execution_context_service_base<select_reactor>
 {
 public:
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -64,17 +64,17 @@ class select_reactor
   };
 
   // Constructor.
-  ASIO_DECL select_reactor(asio::io_service& io_service);
+  ASIO_DECL select_reactor(asio::execution_context& ctx);
 
   // Destructor.
   ASIO_DECL ~select_reactor();
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Recreate internal descriptors following a fork.
-  ASIO_DECL void fork_service(
-      asio::io_service::fork_event fork_ev);
+  ASIO_DECL void notify_fork(
+      asio::execution_context::fork_event fork_ev);
 
   // Initialise the task, but only if the reactor is not in its own thread.
   ASIO_DECL void init_task();
@@ -92,7 +92,7 @@ class select_reactor
   // Post a reactor operation for immediate completion.
   void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op, is_continuation);
+    scheduler_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
@@ -106,13 +106,20 @@ class select_reactor
   ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
   // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor.
+  // its registration from the reactor. The reactor resources associated with
+  // the descriptor must be released by calling cleanup_descriptor_data.
   ASIO_DECL void deregister_descriptor(socket_type descriptor,
       per_descriptor_data&, bool closing);
 
-  // Remote the descriptor's registration from the reactor.
+  // Remove the descriptor's registration from the reactor. The reactor
+  // resources associated with the descriptor must be released by calling
+  // cleanup_descriptor_data.
   ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data& descriptor_data);
+      socket_type descriptor, per_descriptor_data&);
+
+  // Perform any post-deregistration cleanup tasks associated with the
+  // descriptor data.
+  ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&);
 
   // Move descriptor registration from one descriptor_data object to another.
   ASIO_DECL void move_descriptor(socket_type descriptor,
@@ -141,8 +148,14 @@ class select_reactor
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Move the timer operations associated with the given timer.
+  template <typename Time_Traits>
+  void move_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& target,
+      typename timer_queue<Time_Traits>::per_timer_data& source);
+
   // Run select once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(bool block, op_queue<operation>& ops);
+  ASIO_DECL void run(long usec, op_queue<operation>& ops);
 
   // Interrupt the select loop.
   ASIO_DECL void interrupt();
@@ -151,9 +164,6 @@ class select_reactor
 #if defined(ASIO_HAS_IOCP)
   // Run the select loop in the thread.
   ASIO_DECL void run_thread();
-
-  // Entry point for the select loop thread.
-  ASIO_DECL static void call_run_thread(select_reactor* reactor);
 #endif // defined(ASIO_HAS_IOCP)
 
   // Helper function to add a new timer queue.
@@ -163,15 +173,20 @@ class select_reactor
   ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
 
   // Get the timeout value for the select call.
-  ASIO_DECL timeval* get_timeout(timeval& tv);
+  ASIO_DECL timeval* get_timeout(long usec, timeval& tv);
 
   // Cancel all operations associated with the given descriptor. This function
   // does not acquire the select_reactor's mutex.
   ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
       const asio::error_code& ec);
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
+  // The scheduler implementation used to post completions.
+# if defined(ASIO_HAS_IOCP)
+  typedef class win_iocp_io_context scheduler_type;
+# else // defined(ASIO_HAS_IOCP)
+  typedef class scheduler scheduler_type;
+# endif // defined(ASIO_HAS_IOCP)
+  scheduler_type& scheduler_;
 
   // Mutex to protect access to internal data.
   asio::detail::mutex mutex_;
@@ -189,6 +204,10 @@ class select_reactor
   timer_queue_set timer_queues_;
 
 #if defined(ASIO_HAS_IOCP)
+  // Helper class to run the reactor loop in a thread.
+  class thread_function;
+  friend class thread_function;
+
   // Does the reactor loop thread need to stop.
   bool stop_thread_;
 
diff --git a/extern/include/asio/detail/service_registry.hpp b/extern/include/asio/detail/service_registry.hpp
index 9bfdb866..cda63072 100644
--- a/extern/include/asio/detail/service_registry.hpp
+++ b/extern/include/asio/detail/service_registry.hpp
@@ -2,7 +2,7 @@
 // detail/service_registry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,11 +19,15 @@
 #include <typeinfo>
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/noncopyable.hpp"
-#include "asio/io_service.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
+
+class io_context;
+
 namespace detail {
 
 template <typename T>
@@ -33,27 +37,34 @@ class service_registry
   : private noncopyable
 {
 public:
-  // Constructor. Adds the initial service.
-  template <typename Service, typename Arg>
-  service_registry(asio::io_service& o,
-      Service* initial_service, Arg arg);
+  // Constructor.
+  ASIO_DECL service_registry(execution_context& owner);
 
   // Destructor.
   ASIO_DECL ~service_registry();
 
+  // Shutdown all services.
+  ASIO_DECL void shutdown_services();
+
+  // Destroy all services.
+  ASIO_DECL void destroy_services();
+
   // Notify all services of a fork event.
-  ASIO_DECL void notify_fork(asio::io_service::fork_event fork_ev);
+  ASIO_DECL void notify_fork(execution_context::fork_event fork_ev);
 
-  // Get the first service object cast to the specified type. Called during
-  // io_service construction and so performs no locking or type checking.
+  // 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.
   template <typename Service>
-  Service& first_service();
+  Service& use_service();
 
   // 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.
+  // This overload is used for backwards compatibility with services that
+  // inherit from io_context::service.
   template <typename Service>
-  Service& use_service();
+  Service& use_service(io_context& owner);
 
   // Add a service object. Throws on error, in which case ownership of the
   // object is retained by the caller.
@@ -65,70 +76,79 @@ class service_registry
   bool has_service() const;
 
 private:
+  // Initalise a service's key when the key_type typedef is not available.
+  template <typename Service>
+  static void init_key(execution_context::service::key& key, ...);
+
+#if !defined(ASIO_NO_TYPEID)
+  // Initalise a service's key when the key_type typedef is available.
+  template <typename Service>
+  static void init_key(execution_context::service::key& key,
+      typename enable_if<
+        is_base_of<typename Service::key_type, Service>::value>::type*);
+#endif // !defined(ASIO_NO_TYPEID)
+
   // Initialise a service's key based on its id.
-  ASIO_DECL static void init_key(
-      asio::io_service::service::key& key,
-      const asio::io_service::id& id);
+  ASIO_DECL static void init_key_from_id(
+      execution_context::service::key& key,
+      const execution_context::id& id);
 
 #if !defined(ASIO_NO_TYPEID)
   // Initialise a service's key based on its id.
   template <typename Service>
-  static void init_key(asio::io_service::service::key& key,
-      const asio::detail::service_id<Service>& /*id*/);
+  static void init_key_from_id(execution_context::service::key& key,
+      const service_id<Service>& /*id*/);
 #endif // !defined(ASIO_NO_TYPEID)
 
   // Check if a service matches the given id.
   ASIO_DECL static bool keys_match(
-      const asio::io_service::service::key& key1,
-      const asio::io_service::service::key& key2);
+      const execution_context::service::key& key1,
+      const execution_context::service::key& key2);
 
   // The type of a factory function used for creating a service instance.
-  typedef asio::io_service::service*
-    (*factory_type)(asio::io_service&);
+  typedef execution_context::service*(*factory_type)(void*);
 
   // Factory function for creating a service instance.
-  template <typename Service>
-  static asio::io_service::service* create(
-      asio::io_service& owner);
+  template <typename Service, typename Owner>
+  static execution_context::service* create(void* owner);
 
   // Destroy a service instance.
-  ASIO_DECL static void destroy(
-      asio::io_service::service* service);
+  ASIO_DECL static void destroy(execution_context::service* service);
 
   // Helper class to manage service pointers.
   struct auto_service_ptr;
   friend struct auto_service_ptr;
   struct auto_service_ptr
   {
-    asio::io_service::service* ptr_;
+    execution_context::service* ptr_;
     ~auto_service_ptr() { destroy(ptr_); }
   };
 
   // Get the service object corresponding to the specified service key. Will
   // create a new service object automatically if no such object already
   // exists. Ownership of the service object is not transferred to the caller.
-  ASIO_DECL asio::io_service::service* do_use_service(
-      const asio::io_service::service::key& key,
-      factory_type factory);
+  ASIO_DECL execution_context::service* do_use_service(
+      const execution_context::service::key& key,
+      factory_type factory, void* owner);
 
   // Add a service object. Throws on error, in which case ownership of the
   // object is retained by the caller.
   ASIO_DECL void do_add_service(
-      const asio::io_service::service::key& key,
-      asio::io_service::service* new_service);
+      const execution_context::service::key& key,
+      execution_context::service* new_service);
 
   // Check whether a service object with the specified key already exists.
   ASIO_DECL bool do_has_service(
-      const asio::io_service::service::key& key) const;
+      const execution_context::service::key& key) const;
 
   // Mutex to protect access to internal data.
   mutable asio::detail::mutex mutex_;
 
   // The owner of this service registry and the services it contains.
-  asio::io_service& owner_;
+  execution_context& owner_;
 
   // The first service in the list of contained services.
-  asio::io_service::service* first_service_;
+  execution_context::service* first_service_;
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/shared_ptr.hpp b/extern/include/asio/detail/shared_ptr.hpp
deleted file mode 100644
index 0811cc24..00000000
--- a/extern/include/asio/detail/shared_ptr.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// detail/shared_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SHARED_PTR_HPP
-#define ASIO_DETAIL_SHARED_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_STD_SHARED_PTR)
-# include <memory>
-#else // defined(ASIO_HAS_STD_SHARED_PTR)
-# include <boost/shared_ptr.hpp>
-#endif // defined(ASIO_HAS_STD_SHARED_PTR)
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_SHARED_PTR)
-using std::shared_ptr;
-#else // defined(ASIO_HAS_STD_SHARED_PTR)
-using boost::shared_ptr;
-#endif // defined(ASIO_HAS_STD_SHARED_PTR)
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_SHARED_PTR_HPP
diff --git a/extern/include/asio/detail/signal_blocker.hpp b/extern/include/asio/detail/signal_blocker.hpp
index ad668ad5..b6842957 100644
--- a/extern/include/asio/detail/signal_blocker.hpp
+++ b/extern/include/asio/detail/signal_blocker.hpp
@@ -2,7 +2,7 @@
 // detail/signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/signal_handler.hpp b/extern/include/asio/detail/signal_handler.hpp
index 412e082d..d1c99105 100644
--- a/extern/include/asio/detail/signal_handler.hpp
+++ b/extern/include/asio/detail/signal_handler.hpp
@@ -2,7 +2,7 @@
 // detail/signal_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,12 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/signal_op.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -37,17 +39,19 @@ class signal_handler : public signal_op
     : signal_op(&signal_handler::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(h))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     signal_handler* h(static_cast<signal_handler*>(base));
     ptr p = { asio::detail::addressof(h->handler_), h, h };
+    handler_work<Handler> w(h->handler_);
 
-    ASIO_HANDLER_COMPLETION((h));
+    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
@@ -65,7 +69,7 @@ class signal_handler : public signal_op
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/signal_init.hpp b/extern/include/asio/detail/signal_init.hpp
index e9a8cacd..814ff519 100644
--- a/extern/include/asio/detail/signal_init.hpp
+++ b/extern/include/asio/detail/signal_init.hpp
@@ -2,7 +2,7 @@
 // detail/signal_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/signal_op.hpp b/extern/include/asio/detail/signal_op.hpp
index 2f7fd623..c4e364c1 100644
--- a/extern/include/asio/detail/signal_op.hpp
+++ b/extern/include/asio/detail/signal_op.hpp
@@ -2,7 +2,7 @@
 // detail/signal_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/signal_set_service.hpp b/extern/include/asio/detail/signal_set_service.hpp
index d154a091..a18ab709 100644
--- a/extern/include/asio/detail/signal_set_service.hpp
+++ b/extern/include/asio/detail/signal_set_service.hpp
@@ -2,7 +2,7 @@
 // detail/signal_set_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,9 +20,9 @@
 #include <cstddef>
 #include <signal.h>
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/op_queue.hpp"
 #include "asio/detail/signal_handler.hpp"
 #include "asio/detail/signal_op.hpp"
@@ -47,7 +47,8 @@ extern ASIO_DECL struct signal_state* get_signal_state();
 
 extern "C" ASIO_DECL void asio_signal_handler(int signal_number);
 
-class signal_set_service
+class signal_set_service :
+  public service_base<signal_set_service>
 {
 public:
   // Type used for tracking an individual signal registration.
@@ -108,17 +109,17 @@ class signal_set_service
   };
 
   // Constructor.
-  ASIO_DECL signal_set_service(asio::io_service& io_service);
+  ASIO_DECL signal_set_service(asio::io_context& io_context);
 
   // Destructor.
   ASIO_DECL ~signal_set_service();
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Perform fork-related housekeeping.
-  ASIO_DECL void fork_service(
-      asio::io_service::fork_event fork_ev);
+  ASIO_DECL void notify_fork(
+      asio::io_context::fork_event fork_ev);
 
   // Construct a new signal_set implementation.
   ASIO_DECL void construct(implementation_type& impl);
@@ -149,11 +150,11 @@ class signal_set_service
     // Allocate and construct an operation to wrap the handler.
     typedef signal_handler<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "signal_set", &impl, "async_wait"));
+    ASIO_HANDLER_CREATION((io_context_.context(),
+          *p.p, "signal_set", &impl, 0, "async_wait"));
 
     start_wait_op(impl, p.p);
     p.v = p.p = 0;
@@ -178,8 +179,8 @@ class signal_set_service
   // Helper function to start a wait operation.
   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_;
+  // The io_context instance used for dispatching handlers.
+  io_context_impl& io_context_;
 
 #if !defined(ASIO_WINDOWS) \
   && !defined(ASIO_WINDOWS_RUNTIME) \
diff --git a/extern/include/asio/detail/socket_holder.hpp b/extern/include/asio/detail/socket_holder.hpp
index 4fa3143b..99b081f7 100644
--- a/extern/include/asio/detail/socket_holder.hpp
+++ b/extern/include/asio/detail/socket_holder.hpp
@@ -2,7 +2,7 @@
 // detail/socket_holder.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/socket_ops.hpp b/extern/include/asio/detail/socket_ops.hpp
index 49ada0a0..815b0d1c 100644
--- a/extern/include/asio/detail/socket_ops.hpp
+++ b/extern/include/asio/detail/socket_ops.hpp
@@ -2,7 +2,7 @@
 // detail/socket_ops.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,9 +18,8 @@
 #include "asio/detail/config.hpp"
 
 #include "asio/error_code.hpp"
-#include "asio/detail/shared_ptr.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/socket_types.hpp"
-#include "asio/detail/weak_ptr.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -264,12 +263,16 @@ ASIO_DECL int select(int nfds, fd_set* readfds, fd_set* writefds,
     fd_set* exceptfds, timeval* timeout, asio::error_code& ec);
 
 ASIO_DECL int poll_read(socket_type s,
-    state_type state, asio::error_code& ec);
+    state_type state, int msec, asio::error_code& ec);
 
 ASIO_DECL int poll_write(socket_type s,
-    state_type state, asio::error_code& ec);
+    state_type state, int msec, asio::error_code& ec);
 
-ASIO_DECL int poll_connect(socket_type s, asio::error_code& ec);
+ASIO_DECL int poll_error(socket_type s,
+    state_type state, int msec, asio::error_code& ec);
+
+ASIO_DECL int poll_connect(socket_type s,
+    int msec, asio::error_code& ec);
 
 #endif // !defined(ASIO_WINDOWS_RUNTIME)
 
diff --git a/extern/include/asio/detail/socket_option.hpp b/extern/include/asio/detail/socket_option.hpp
index 7241ab7b..6852d569 100644
--- a/extern/include/asio/detail/socket_option.hpp
+++ b/extern/include/asio/detail/socket_option.hpp
@@ -2,7 +2,7 @@
 // detail/socket_option.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/socket_select_interrupter.hpp b/extern/include/asio/detail/socket_select_interrupter.hpp
index 470ce789..7351070c 100644
--- a/extern/include/asio/detail/socket_select_interrupter.hpp
+++ b/extern/include/asio/detail/socket_select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/socket_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/socket_types.hpp b/extern/include/asio/detail/socket_types.hpp
index f2600c20..d354343c 100644
--- a/extern/include/asio/detail/socket_types.hpp
+++ b/extern/include/asio/detail/socket_types.hpp
@@ -2,7 +2,7 @@
 // detail/socket_types.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -30,14 +30,16 @@
 #   define ASIO_WSPIAPI_H_DEFINED
 #  endif // !defined(_WSPIAPI_H_)
 # endif // defined(__BORLANDC__)
+# include <winsock2.h>
+# include <ws2tcpip.h>
 # if defined(WINAPI_FAMILY)
 #  if ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0)
 #   include <windows.h>
 #  endif // ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0)
 # endif // defined(WINAPI_FAMILY)
-# include <winsock2.h>
-# include <ws2tcpip.h>
-# include <mswsock.h>
+# if !defined(ASIO_WINDOWS_APP)
+#  include <mswsock.h>
+# endif // !defined(ASIO_WINDOWS_APP)
 # if defined(ASIO_WSPIAPI_H_DEFINED)
 #  undef _WSPIAPI_H_
 #  undef ASIO_WSPIAPI_H_DEFINED
@@ -47,13 +49,20 @@
 #   pragma comment(lib, "ws2.lib")
 #  elif defined(_MSC_VER) || defined(__BORLANDC__)
 #   pragma comment(lib, "ws2_32.lib")
-#   pragma comment(lib, "mswsock.lib")
+#   if !defined(ASIO_WINDOWS_APP)
+#    pragma comment(lib, "mswsock.lib")
+#   endif // !defined(ASIO_WINDOWS_APP)
 #  endif // defined(_MSC_VER) || defined(__BORLANDC__)
 # endif // !defined(ASIO_NO_DEFAULT_LINKED_LIBS)
 # include "asio/detail/old_win_sdk_compat.hpp"
 #else
 # include <sys/ioctl.h>
-# if !defined(__SYMBIAN32__)
+# if (defined(__MACH__) && defined(__APPLE__)) \
+   || defined(__FreeBSD__) || defined(__NetBSD__) \
+   || defined(__OpenBSD__) || defined(__linux__) \
+   || defined(__EMSCRIPTEN__)
+#  include <poll.h>
+# elif !defined(__SYMBIAN32__)
 #  include <sys/poll.h>
 # endif
 # include <sys/types.h>
@@ -143,6 +152,7 @@ typedef int signed_size_type;
 # define ASIO_OS_DEF_SO_DONTROUTE 0x10
 # define ASIO_OS_DEF_SO_KEEPALIVE 0x8
 # define ASIO_OS_DEF_SO_LINGER 0x80
+# define ASIO_OS_DEF_SO_OOBINLINE 0x100
 # define ASIO_OS_DEF_SO_SNDBUF 0x1001
 # define ASIO_OS_DEF_SO_RCVBUF 0x1002
 # define ASIO_OS_DEF_SO_SNDLOWAT 0x1003
@@ -227,6 +237,7 @@ typedef int signed_size_type;
 # define ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
 # define ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
 # define ASIO_OS_DEF_SO_LINGER SO_LINGER
+# define ASIO_OS_DEF_SO_OOBINLINE SO_OOBINLINE
 # define ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
 # define ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
 # define ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
@@ -342,6 +353,7 @@ typedef int signed_size_type;
 # define ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
 # define ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
 # define ASIO_OS_DEF_SO_LINGER SO_LINGER
+# define ASIO_OS_DEF_SO_OOBINLINE SO_OOBINLINE
 # define ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
 # define ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
 # define ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
diff --git a/extern/include/asio/detail/solaris_fenced_block.hpp b/extern/include/asio/detail/solaris_fenced_block.hpp
index a4d1eafb..d48f6a37 100644
--- a/extern/include/asio/detail/solaris_fenced_block.hpp
+++ b/extern/include/asio/detail/solaris_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/solaris_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,7 @@
 #if defined(__sun)
 
 #include <atomic.h>
+#include "asio/detail/noncopyable.hpp"
 
 #include "asio/detail/push_options.hpp"
 
diff --git a/extern/include/asio/detail/static_mutex.hpp b/extern/include/asio/detail/static_mutex.hpp
index bc84118e..8f2bc02a 100644
--- a/extern/include/asio/detail/static_mutex.hpp
+++ b/extern/include/asio/detail/static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/std_event.hpp b/extern/include/asio/detail/std_event.hpp
index b7c5e202..5639ecdd 100644
--- a/extern/include/asio/detail/std_event.hpp
+++ b/extern/include/asio/detail/std_event.hpp
@@ -2,7 +2,7 @@
 // detail/std_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/std_fenced_block.hpp b/extern/include/asio/detail/std_fenced_block.hpp
new file mode 100644
index 00000000..0d8ade02
--- /dev/null
+++ b/extern/include/asio/detail/std_fenced_block.hpp
@@ -0,0 +1,62 @@
+//
+// detail/std_fenced_block.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_STD_FENCED_BLOCK_HPP
+#define ASIO_DETAIL_STD_FENCED_BLOCK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_STD_ATOMIC)
+
+#include <atomic>
+#include "asio/detail/noncopyable.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+class std_fenced_block
+  : private noncopyable
+{
+public:
+  enum half_t { half };
+  enum full_t { full };
+
+  // Constructor for a half fenced block.
+  explicit std_fenced_block(half_t)
+  {
+  }
+
+  // Constructor for a full fenced block.
+  explicit std_fenced_block(full_t)
+  {
+    std::atomic_thread_fence(std::memory_order_acquire);
+  }
+
+  // Destructor.
+  ~std_fenced_block()
+  {
+    std::atomic_thread_fence(std::memory_order_release);
+  }
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_STD_ATOMIC)
+
+#endif // ASIO_DETAIL_STD_FENCED_BLOCK_HPP
diff --git a/extern/include/asio/detail/std_global.hpp b/extern/include/asio/detail/std_global.hpp
new file mode 100644
index 00000000..0c5173e6
--- /dev/null
+++ b/extern/include/asio/detail/std_global.hpp
@@ -0,0 +1,70 @@
+//
+// detail/std_global.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_STD_GLOBAL_HPP
+#define ASIO_DETAIL_STD_GLOBAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_STD_CALL_ONCE)
+
+#include <exception>
+#include <mutex>
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+struct std_global_impl
+{
+  // Helper function to perform initialisation.
+  static void do_init()
+  {
+    instance_.ptr_ = new T;
+  }
+
+  // Destructor automatically cleans up the global.
+  ~std_global_impl()
+  {
+    delete ptr_;
+  }
+
+  static std::once_flag init_once_;
+  static std_global_impl instance_;
+  T* ptr_;
+};
+
+template <typename T>
+std::once_flag std_global_impl<T>::init_once_;
+
+template <typename T>
+std_global_impl<T> std_global_impl<T>::instance_;
+
+template <typename T>
+T& std_global()
+{
+  std::call_once(std_global_impl<T>::init_once_, &std_global_impl<T>::do_init);
+  return *std_global_impl<T>::instance_.ptr_;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_STD_CALL_ONCE)
+
+#endif // ASIO_DETAIL_STD_GLOBAL_HPP
diff --git a/extern/include/asio/detail/std_mutex.hpp b/extern/include/asio/detail/std_mutex.hpp
index 478aa1a2..159049e8 100644
--- a/extern/include/asio/detail/std_mutex.hpp
+++ b/extern/include/asio/detail/std_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/std_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/std_static_mutex.hpp b/extern/include/asio/detail/std_static_mutex.hpp
index b2abadff..e9c9dc5e 100644
--- a/extern/include/asio/detail/std_static_mutex.hpp
+++ b/extern/include/asio/detail/std_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/std_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/std_thread.hpp b/extern/include/asio/detail/std_thread.hpp
index a16a8974..a240308d 100644
--- a/extern/include/asio/detail/std_thread.hpp
+++ b/extern/include/asio/detail/std_thread.hpp
@@ -2,7 +2,7 @@
 // detail/std_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -51,6 +51,12 @@ class std_thread
       thread_.join();
   }
 
+  // Get number of CPUs.
+  static std::size_t hardware_concurrency()
+  {
+    return std::thread::hardware_concurrency();
+  }
+
 private:
   std::thread thread_;
 };
diff --git a/extern/include/asio/detail/strand_executor_service.hpp b/extern/include/asio/detail/strand_executor_service.hpp
new file mode 100644
index 00000000..67e84274
--- /dev/null
+++ b/extern/include/asio/detail/strand_executor_service.hpp
@@ -0,0 +1,142 @@
+//
+// detail/strand_executor_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP
+#define ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/atomic_count.hpp"
+#include "asio/detail/executor_op.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/mutex.hpp"
+#include "asio/detail/op_queue.hpp"
+#include "asio/detail/scheduler_operation.hpp"
+#include "asio/detail/scoped_ptr.hpp"
+#include "asio/execution_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+// Default service implementation for a strand.
+class strand_executor_service
+  : public execution_context_service_base<strand_executor_service>
+{
+public:
+  // The underlying implementation of a strand.
+  class strand_impl
+  {
+  public:
+    ASIO_DECL ~strand_impl();
+
+  private:
+    friend class strand_executor_service;
+
+    // Mutex to protect access to internal data.
+    mutex* mutex_;
+
+    // Indicates whether the strand is currently "locked" by a handler. This
+    // means that there is a handler upcall in progress, or that the strand
+    // itself has been scheduled in order to invoke some pending handlers.
+    bool locked_;
+
+    // Indicates that the strand has been shut down and will accept no further
+    // handlers.
+    bool shutdown_;
+
+    // The handlers that are waiting on the strand but should not be run until
+    // after the next time the strand is scheduled. This queue must only be
+    // modified while the mutex is locked.
+    op_queue<scheduler_operation> waiting_queue_;
+
+    // The handlers that are ready to be run. Logically speaking, these are the
+    // handlers that hold the strand's lock. The ready queue is only modified
+    // from within the strand and so may be accessed without locking the mutex.
+    op_queue<scheduler_operation> ready_queue_;
+
+    // Pointers to adjacent handle implementations in linked list.
+    strand_impl* next_;
+    strand_impl* prev_;
+
+    // The strand service in where the implementation is held.
+    strand_executor_service* service_;
+  };
+
+  typedef shared_ptr<strand_impl> implementation_type;
+
+  // Construct a new strand service for the specified context.
+  ASIO_DECL explicit strand_executor_service(execution_context& context);
+
+  // Destroy all user-defined handler objects owned by the service.
+  ASIO_DECL void shutdown();
+
+  // Create a new strand_executor implementation.
+  ASIO_DECL implementation_type create_implementation();
+
+  // Request invocation of the given function.
+  template <typename Executor, typename Function, typename Allocator>
+  static void dispatch(const implementation_type& impl, Executor& ex,
+      ASIO_MOVE_ARG(Function) function, const Allocator& a);
+
+  // Request invocation of the given function and return immediately.
+  template <typename Executor, typename Function, typename Allocator>
+  static void post(const implementation_type& impl, Executor& ex,
+      ASIO_MOVE_ARG(Function) function, const Allocator& a);
+
+  // Request invocation of the given function and return immediately.
+  template <typename Executor, typename Function, typename Allocator>
+  static void defer(const implementation_type& impl, Executor& ex,
+      ASIO_MOVE_ARG(Function) function, const Allocator& a);
+
+  // Determine whether the strand is running in the current thread.
+  ASIO_DECL static bool running_in_this_thread(
+      const implementation_type& impl);
+
+private:
+  friend class strand_impl;
+  template <typename Executor> class invoker;
+
+  // Adds a function to the strand. Returns true if it acquires the lock.
+  ASIO_DECL static bool enqueue(const implementation_type& impl,
+      scheduler_operation* op);
+
+  // Mutex to protect access to the service-wide state.
+  mutex mutex_;
+
+  // Number of mutexes shared between all strand objects.
+  enum { num_mutexes = 193 };
+
+  // Pool of mutexes.
+  scoped_ptr<mutex> mutexes_[num_mutexes];
+
+  // Extra value used when hashing to prevent recycled memory locations from
+  // getting the same mutex.
+  std::size_t salt_;
+
+  // The head of a linked list of all implementations.
+  strand_impl* impl_list_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/detail/impl/strand_executor_service.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/detail/impl/strand_executor_service.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP
diff --git a/extern/include/asio/detail/strand_service.hpp b/extern/include/asio/detail/strand_service.hpp
index b0e66faf..edc14a0f 100644
--- a/extern/include/asio/detail/strand_service.hpp
+++ b/extern/include/asio/detail/strand_service.hpp
@@ -2,7 +2,7 @@
 // detail/strand_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/op_queue.hpp"
 #include "asio/detail/operation.hpp"
@@ -74,20 +74,20 @@ class strand_service
 
   typedef strand_impl* implementation_type;
 
-  // Construct a new strand service for the specified io_service.
-  ASIO_DECL explicit strand_service(asio::io_service& io_service);
+  // Construct a new strand service for the specified io_context.
+  ASIO_DECL explicit strand_service(asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Construct a new strand implementation.
   ASIO_DECL void construct(implementation_type& impl);
 
-  // Request the io_service to invoke the given handler.
+  // Request the io_context to invoke the given handler.
   template <typename Handler>
   void dispatch(implementation_type& impl, Handler& handler);
 
-  // Request the io_service to invoke the given handler and return immediately.
+  // Request the io_context to invoke the given handler and return immediately.
   template <typename Handler>
   void post(implementation_type& impl, Handler& handler);
 
@@ -104,12 +104,12 @@ class strand_service
   ASIO_DECL void do_post(implementation_type& impl,
       operation* op, bool is_continuation);
 
-  ASIO_DECL static void do_complete(io_service_impl* owner,
+  ASIO_DECL static void do_complete(void* owner,
       operation* base, const asio::error_code& ec,
       std::size_t bytes_transferred);
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
+  // The io_context implementation used to post completions.
+  io_context_impl& io_context_;
 
   // Mutex to protect access to the array of implementations.
   asio::detail::mutex mutex_;
diff --git a/extern/include/asio/detail/string_view.hpp b/extern/include/asio/detail/string_view.hpp
new file mode 100644
index 00000000..f09cebc2
--- /dev/null
+++ b/extern/include/asio/detail/string_view.hpp
@@ -0,0 +1,47 @@
+//
+// detail/string_view.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_STRING_VIEW_HPP
+#define ASIO_DETAIL_STRING_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+#if defined(ASIO_HAS_STD_STRING_VIEW)
+# include <string_view>
+#elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+# include <experimental/string_view>
+#else // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+# error ASIO_HAS_STRING_VIEW is set but no string_view is available
+#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+
+namespace asio {
+
+#if defined(ASIO_HAS_STD_STRING_VIEW)
+using std::basic_string_view;
+using std::string_view;
+#elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+using std::experimental::basic_string_view;
+using std::experimental::string_view;
+#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
+
+} // namespace asio
+
+# define ASIO_STRING_VIEW_PARAM asio::string_view
+#else // defined(ASIO_HAS_STRING_VIEW)
+# define ASIO_STRING_VIEW_PARAM const std::string&
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+#endif // ASIO_DETAIL_STRING_VIEW_HPP
diff --git a/extern/include/asio/detail/thread.hpp b/extern/include/asio/detail/thread.hpp
index 3592a70e..ea556dba 100644
--- a/extern/include/asio/detail/thread.hpp
+++ b/extern/include/asio/detail/thread.hpp
@@ -2,7 +2,7 @@
 // detail/thread.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,6 +22,8 @@
 #elif defined(ASIO_WINDOWS)
 # if defined(UNDER_CE)
 #  include "asio/detail/wince_thread.hpp"
+# elif defined(ASIO_WINDOWS_APP)
+#  include "asio/detail/winapp_thread.hpp"
 # else
 #  include "asio/detail/win_thread.hpp"
 # endif
@@ -41,6 +43,8 @@ typedef null_thread thread;
 #elif defined(ASIO_WINDOWS)
 # if defined(UNDER_CE)
 typedef wince_thread thread;
+# elif defined(ASIO_WINDOWS_APP)
+typedef winapp_thread thread;
 # else
 typedef win_thread thread;
 # endif
diff --git a/extern/include/asio/detail/thread_context.hpp b/extern/include/asio/detail/thread_context.hpp
new file mode 100644
index 00000000..88b4f311
--- /dev/null
+++ b/extern/include/asio/detail/thread_context.hpp
@@ -0,0 +1,42 @@
+//
+// detail/thread_context.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_THREAD_CONTEXT_HPP
+#define ASIO_DETAIL_THREAD_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <climits>
+#include <cstddef>
+#include "asio/detail/call_stack.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+class thread_info_base;
+
+// Base class for things that manage threads (scheduler, win_iocp_io_context).
+class thread_context
+{
+public:
+  // Per-thread call stack to track the state of each thread in the context.
+  typedef call_stack<thread_context, thread_info_base> thread_call_stack;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_THREAD_CONTEXT_HPP
diff --git a/extern/include/asio/detail/thread_group.hpp b/extern/include/asio/detail/thread_group.hpp
new file mode 100644
index 00000000..1e400b03
--- /dev/null
+++ b/extern/include/asio/detail/thread_group.hpp
@@ -0,0 +1,89 @@
+//
+// detail/thread_group.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_THREAD_GROUP_HPP
+#define ASIO_DETAIL_THREAD_GROUP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/scoped_ptr.hpp"
+#include "asio/detail/thread.hpp"
+
+namespace asio {
+namespace detail {
+
+class thread_group
+{
+public:
+  // Constructor initialises an empty thread group.
+  thread_group()
+    : first_(0)
+  {
+  }
+
+  // Destructor joins any remaining threads in the group.
+  ~thread_group()
+  {
+    join();
+  }
+
+  // Create a new thread in the group.
+  template <typename Function>
+  void create_thread(Function f)
+  {
+    first_ = new item(f, first_);
+  }
+
+  // Create new threads in the group.
+  template <typename Function>
+  void create_threads(Function f, std::size_t num_threads)
+  {
+    for (std::size_t i = 0; i < num_threads; ++i)
+      create_thread(f);
+  }
+
+  // Wait for all threads in the group to exit.
+  void join()
+  {
+    while (first_)
+    {
+      first_->thread_.join();
+      item* tmp = first_;
+      first_ = first_->next_;
+      delete tmp;
+    }
+  }
+
+private:
+  // Structure used to track a single thread in the group.
+  struct item
+  {
+    template <typename Function>
+    explicit item(Function f, item* next)
+      : thread_(f),
+        next_(next)
+    {
+    }
+
+    asio::detail::thread thread_;
+    item* next_;
+  };
+
+  // The first thread in the group.
+  item* first_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#endif // ASIO_DETAIL_THREAD_GROUP_HPP
diff --git a/extern/include/asio/detail/thread_info_base.hpp b/extern/include/asio/detail/thread_info_base.hpp
index dd52468a..1b222074 100644
--- a/extern/include/asio/detail/thread_info_base.hpp
+++ b/extern/include/asio/detail/thread_info_base.hpp
@@ -2,7 +2,7 @@
 // detail/thread_info_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,26 +28,53 @@ class thread_info_base
   : private noncopyable
 {
 public:
+  struct default_tag
+  {
+    enum { mem_index = 0 };
+  };
+
+  struct awaitee_tag
+  {
+    enum { mem_index = 1 };
+  };
+
   thread_info_base()
-    : reusable_memory_(0)
   {
+    for (int i = 0; i < max_mem_index; ++i)
+      reusable_memory_[i] = 0;
   }
 
   ~thread_info_base()
   {
-    if (reusable_memory_)
-      ::operator delete(reusable_memory_);
+    for (int i = 0; i < max_mem_index; ++i)
+      if (reusable_memory_[i])
+        ::operator delete(reusable_memory_[i]);
   }
 
   static void* allocate(thread_info_base* this_thread, std::size_t size)
   {
-    if (this_thread && this_thread->reusable_memory_)
+    return allocate(default_tag(), this_thread, size);
+  }
+
+  static void deallocate(thread_info_base* this_thread,
+      void* pointer, std::size_t size)
+  {
+    deallocate(default_tag(), this_thread, pointer, size);
+  }
+
+  template <typename Purpose>
+  static void* allocate(Purpose, thread_info_base* this_thread,
+      std::size_t size)
+  {
+    std::size_t chunks = (size + chunk_size - 1) / chunk_size;
+
+    if (this_thread && this_thread->reusable_memory_[Purpose::mem_index])
     {
-      void* const pointer = this_thread->reusable_memory_;
-      this_thread->reusable_memory_ = 0;
+      void* const pointer = this_thread->reusable_memory_[Purpose::mem_index];
+      this_thread->reusable_memory_[Purpose::mem_index] = 0;
 
       unsigned char* const mem = static_cast<unsigned char*>(pointer);
-      if (static_cast<std::size_t>(mem[0]) >= size)
+      if (static_cast<std::size_t>(mem[0]) >= chunks)
       {
         mem[size] = mem[0];
         return pointer;
@@ -56,22 +83,23 @@ class thread_info_base
       ::operator delete(pointer);
     }
 
-    void* const pointer = ::operator new(size + 1);
+    void* const pointer = ::operator new(chunks * chunk_size + 1);
     unsigned char* const mem = static_cast<unsigned char*>(pointer);
-    mem[size] = (size <= UCHAR_MAX) ? static_cast<unsigned char>(size) : 0;
+    mem[size] = (chunks <= UCHAR_MAX) ? static_cast<unsigned char>(chunks) : 0;
     return pointer;
   }
 
-  static void deallocate(thread_info_base* this_thread,
+  template <typename Purpose>
+  static void deallocate(Purpose, thread_info_base* this_thread,
       void* pointer, std::size_t size)
   {
-    if (size <= UCHAR_MAX)
+    if (size <= chunk_size * UCHAR_MAX)
     {
-      if (this_thread && this_thread->reusable_memory_ == 0)
+      if (this_thread && this_thread->reusable_memory_[Purpose::mem_index] == 0)
       {
         unsigned char* const mem = static_cast<unsigned char*>(pointer);
         mem[0] = mem[size];
-        this_thread->reusable_memory_ = pointer;
+        this_thread->reusable_memory_[Purpose::mem_index] = pointer;
         return;
       }
     }
@@ -80,7 +108,9 @@ class thread_info_base
   }
 
 private:
-  void* reusable_memory_;
+  enum { chunk_size = 4 };
+  enum { max_mem_index = 2 };
+  void* reusable_memory_[max_mem_index];
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/throw_error.hpp b/extern/include/asio/detail/throw_error.hpp
index 5eff60c1..5dd87855 100644
--- a/extern/include/asio/detail/throw_error.hpp
+++ b/extern/include/asio/detail/throw_error.hpp
@@ -2,7 +2,7 @@
 // detail/throw_error.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/throw_exception.hpp b/extern/include/asio/detail/throw_exception.hpp
index 3cec3178..f9f7bfb9 100644
--- a/extern/include/asio/detail/throw_exception.hpp
+++ b/extern/include/asio/detail/throw_exception.hpp
@@ -2,7 +2,7 @@
 // detail/throw_exception.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/timer_queue.hpp b/extern/include/asio/detail/timer_queue.hpp
index 5fd9f7ff..380e7791 100644
--- a/extern/include/asio/detail/timer_queue.hpp
+++ b/extern/include/asio/detail/timer_queue.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -46,7 +46,11 @@ class timer_queue
   class per_timer_data
   {
   public:
-    per_timer_data() : next_(0), prev_(0) {}
+    per_timer_data() :
+      heap_index_((std::numeric_limits<std::size_t>::max)()),
+      next_(0), prev_(0)
+    {
+    }
 
   private:
     friend class timer_queue;
@@ -188,6 +192,29 @@ class timer_queue
     return num_cancelled;
   }
 
+  // Move operations from one timer to another, empty timer.
+  void move_timer(per_timer_data& target, per_timer_data& source)
+  {
+    target.op_queue_.push(source.op_queue_);
+
+    target.heap_index_ = source.heap_index_;
+    source.heap_index_ = (std::numeric_limits<std::size_t>::max)();
+
+    if (target.heap_index_ < heap_.size())
+      heap_[target.heap_index_].timer_ = &target;
+
+    if (timers_ == &source)
+      timers_ = &target;
+    if (source.prev_)
+      source.prev_->next_ = &target;
+    if (source.next_)
+      source.next_->prev_= &target;
+    target.next_ = source.next_;
+    target.prev_ = source.prev_;
+    source.next_ = 0;
+    source.prev_ = 0;
+  }
+
 private:
   // Move the item at the given index up the heap to its correct position.
   void up_heap(std::size_t index)
diff --git a/extern/include/asio/detail/timer_queue_base.hpp b/extern/include/asio/detail/timer_queue_base.hpp
index 56101fd1..4af995f2 100644
--- a/extern/include/asio/detail/timer_queue_base.hpp
+++ b/extern/include/asio/detail/timer_queue_base.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/timer_queue_ptime.hpp b/extern/include/asio/detail/timer_queue_ptime.hpp
index 0062fea3..84e83385 100644
--- a/extern/include/asio/detail/timer_queue_ptime.hpp
+++ b/extern/include/asio/detail/timer_queue_ptime.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue_ptime.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,13 +15,15 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_BOOST_DATE_TIME)
+
 #include "asio/time_traits.hpp"
 #include "asio/detail/timer_queue.hpp"
 
 #include "asio/detail/push_options.hpp"
 
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-
 namespace asio {
 namespace detail {
 
@@ -75,6 +77,10 @@ class timer_queue<time_traits<boost::posix_time::ptime> >
       per_timer_data& timer, op_queue<operation>& ops,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Move operations from one timer to another, empty timer.
+  ASIO_DECL void move_timer(per_timer_data& target,
+      per_timer_data& source);
+
 private:
   timer_queue<forwarding_posix_time_traits> impl_;
 };
@@ -82,12 +88,12 @@ class timer_queue<time_traits<boost::posix_time::ptime> >
 } // namespace detail
 } // namespace asio
 
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
 #include "asio/detail/pop_options.hpp"
 
 #if defined(ASIO_HEADER_ONLY)
 # include "asio/detail/impl/timer_queue_ptime.ipp"
 #endif // defined(ASIO_HEADER_ONLY)
 
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+
 #endif // ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
diff --git a/extern/include/asio/detail/timer_queue_set.hpp b/extern/include/asio/detail/timer_queue_set.hpp
index e8bf6491..0ea372ae 100644
--- a/extern/include/asio/detail/timer_queue_set.hpp
+++ b/extern/include/asio/detail/timer_queue_set.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue_set.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/timer_scheduler.hpp b/extern/include/asio/detail/timer_scheduler.hpp
index 34f82596..b1f8df45 100644
--- a/extern/include/asio/detail/timer_scheduler.hpp
+++ b/extern/include/asio/detail/timer_scheduler.hpp
@@ -2,7 +2,7 @@
 // detail/timer_scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,7 +21,7 @@
 #if defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/winrt_timer_scheduler.hpp"
 #elif defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_service.hpp"
+# include "asio/detail/win_iocp_io_context.hpp"
 #elif defined(ASIO_HAS_EPOLL)
 # include "asio/detail/epoll_reactor.hpp"
 #elif defined(ASIO_HAS_KQUEUE)
diff --git a/extern/include/asio/detail/timer_scheduler_fwd.hpp b/extern/include/asio/detail/timer_scheduler_fwd.hpp
index 69b0586b..80bae503 100644
--- a/extern/include/asio/detail/timer_scheduler_fwd.hpp
+++ b/extern/include/asio/detail/timer_scheduler_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/timer_scheduler_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,7 +23,7 @@ namespace detail {
 #if defined(ASIO_WINDOWS_RUNTIME)
 typedef class winrt_timer_scheduler timer_scheduler;
 #elif defined(ASIO_HAS_IOCP)
-typedef class win_iocp_io_service timer_scheduler;
+typedef class win_iocp_io_context timer_scheduler;
 #elif defined(ASIO_HAS_EPOLL)
 typedef class epoll_reactor timer_scheduler;
 #elif defined(ASIO_HAS_KQUEUE)
diff --git a/extern/include/asio/detail/tss_ptr.hpp b/extern/include/asio/detail/tss_ptr.hpp
index af80f287..e628abe9 100644
--- a/extern/include/asio/detail/tss_ptr.hpp
+++ b/extern/include/asio/detail/tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/type_traits.hpp b/extern/include/asio/detail/type_traits.hpp
index 56614f3f..edf09281 100644
--- a/extern/include/asio/detail/type_traits.hpp
+++ b/extern/include/asio/detail/type_traits.hpp
@@ -2,7 +2,7 @@
 // detail/type_traits.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,6 +21,11 @@
 # include <type_traits>
 #else // defined(ASIO_HAS_TYPE_TRAITS)
 # include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/conditional.hpp>
+# include <boost/type_traits/decay.hpp>
+# include <boost/type_traits/integral_constant.hpp>
+# include <boost/type_traits/is_base_of.hpp>
+# include <boost/type_traits/is_class.hpp>
 # include <boost/type_traits/is_const.hpp>
 # include <boost/type_traits/is_convertible.hpp>
 # include <boost/type_traits/is_function.hpp>
@@ -28,29 +33,52 @@
 # include <boost/type_traits/remove_pointer.hpp>
 # include <boost/type_traits/remove_reference.hpp>
 # include <boost/utility/enable_if.hpp>
+# include <boost/utility/result_of.hpp>
 #endif // defined(ASIO_HAS_TYPE_TRAITS)
 
 namespace asio {
 
 #if defined(ASIO_HAS_STD_TYPE_TRAITS)
 using std::add_const;
+using std::conditional;
+using std::decay;
 using std::enable_if;
+using std::false_type;
+using std::integral_constant;
+using std::is_base_of;
+using std::is_class;
 using std::is_const;
 using std::is_convertible;
 using std::is_function;
 using std::is_same;
 using std::remove_pointer;
 using std::remove_reference;
+#if defined(ASIO_HAS_STD_INVOKE_RESULT)
+template <typename> struct result_of;
+template <typename F, typename... Args>
+struct result_of<F(Args...)> : std::invoke_result<F, Args...> {};
+#else // defined(ASIO_HAS_STD_INVOKE_RESULT)
+using std::result_of;
+#endif // defined(ASIO_HAS_STD_INVOKE_RESULT)
+using std::true_type;
 #else // defined(ASIO_HAS_STD_TYPE_TRAITS)
 using boost::add_const;
 template <bool Condition, typename Type = void>
 struct enable_if : boost::enable_if_c<Condition, Type> {};
+using boost::conditional;
+using boost::decay;
+using boost::false_type;
+using boost::integral_constant;
+using boost::is_base_of;
+using boost::is_class;
 using boost::is_const;
 using boost::is_convertible;
 using boost::is_function;
 using boost::is_same;
 using boost::remove_pointer;
 using boost::remove_reference;
+using boost::result_of;
+using boost::true_type;
 #endif // defined(ASIO_HAS_STD_TYPE_TRAITS)
 
 } // namespace asio
diff --git a/extern/include/asio/detail/variadic_templates.hpp b/extern/include/asio/detail/variadic_templates.hpp
index 0c2ba931..d54eb4e4 100644
--- a/extern/include/asio/detail/variadic_templates.hpp
+++ b/extern/include/asio/detail/variadic_templates.hpp
@@ -2,7 +2,7 @@
 // detail/variadic_templates.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -34,27 +34,83 @@
 
 # define ASIO_VARIADIC_TARGS(n) ASIO_VARIADIC_TARGS_##n
 
-# define ASIO_VARIADIC_TARGS_1 x1
-# define ASIO_VARIADIC_TARGS_2 x1, x2
-# define ASIO_VARIADIC_TARGS_3 x1, x2, x3
-# define ASIO_VARIADIC_TARGS_4 x1, x2, x3, x4
-# define ASIO_VARIADIC_TARGS_5 x1, x2, x3, x4, x5
+# define ASIO_VARIADIC_TARGS_1 T1
+# define ASIO_VARIADIC_TARGS_2 T1, T2
+# define ASIO_VARIADIC_TARGS_3 T1, T2, T3
+# define ASIO_VARIADIC_TARGS_4 T1, T2, T3, T4
+# define ASIO_VARIADIC_TARGS_5 T1, T2, T3, T4, T5
 
-# define ASIO_VARIADIC_PARAMS(n) ASIO_VARIADIC_PARAMS_##n
+# define ASIO_VARIADIC_BYVAL_PARAMS(n) \
+  ASIO_VARIADIC_BYVAL_PARAMS_##n
 
-# define ASIO_VARIADIC_PARAMS_1 T1 x1
-# define ASIO_VARIADIC_PARAMS_2 T1 x1, T2 x2
-# define ASIO_VARIADIC_PARAMS_3 T1 x1, T2 x2, T3 x3
-# define ASIO_VARIADIC_PARAMS_4 T1 x1, T2 x2, T3 x3, T4 x4
-# define ASIO_VARIADIC_PARAMS_5 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5
+# define ASIO_VARIADIC_BYVAL_PARAMS_1 T1 x1
+# define ASIO_VARIADIC_BYVAL_PARAMS_2 T1 x1, T2 x2
+# define ASIO_VARIADIC_BYVAL_PARAMS_3 T1 x1, T2 x2, T3 x3
+# define ASIO_VARIADIC_BYVAL_PARAMS_4 T1 x1, T2 x2, T3 x3, T4 x4
+# define ASIO_VARIADIC_BYVAL_PARAMS_5 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5
 
-# define ASIO_VARIADIC_ARGS(n) ASIO_VARIADIC_ARGS_##n
+# define ASIO_VARIADIC_BYVAL_ARGS(n) \
+  ASIO_VARIADIC_BYVAL_ARGS_##n
 
-# define ASIO_VARIADIC_ARGS_1 x1
-# define ASIO_VARIADIC_ARGS_2 x1, x2
-# define ASIO_VARIADIC_ARGS_3 x1, x2, x3
-# define ASIO_VARIADIC_ARGS_4 x1, x2, x3, x4
-# define ASIO_VARIADIC_ARGS_5 x1, x2, x3, x4, x5
+# define ASIO_VARIADIC_BYVAL_ARGS_1 x1
+# define ASIO_VARIADIC_BYVAL_ARGS_2 x1, x2
+# define ASIO_VARIADIC_BYVAL_ARGS_3 x1, x2, x3
+# define ASIO_VARIADIC_BYVAL_ARGS_4 x1, x2, x3, x4
+# define ASIO_VARIADIC_BYVAL_ARGS_5 x1, x2, x3, x4, x5
+
+# define ASIO_VARIADIC_MOVE_PARAMS(n) \
+  ASIO_VARIADIC_MOVE_PARAMS_##n
+
+# define ASIO_VARIADIC_MOVE_PARAMS_1 \
+  ASIO_MOVE_ARG(T1) x1
+# define ASIO_VARIADIC_MOVE_PARAMS_2 \
+  ASIO_MOVE_ARG(T1) x1, ASIO_MOVE_ARG(T2) x2
+# define ASIO_VARIADIC_MOVE_PARAMS_3 \
+  ASIO_MOVE_ARG(T1) x1, ASIO_MOVE_ARG(T2) x2, \
+  ASIO_MOVE_ARG(T3) x3
+# define ASIO_VARIADIC_MOVE_PARAMS_4 \
+  ASIO_MOVE_ARG(T1) x1, ASIO_MOVE_ARG(T2) x2, \
+  ASIO_MOVE_ARG(T3) x3, ASIO_MOVE_ARG(T4) x4
+# define ASIO_VARIADIC_MOVE_PARAMS_5 \
+  ASIO_MOVE_ARG(T1) x1, ASIO_MOVE_ARG(T2) x2, \
+  ASIO_MOVE_ARG(T3) x3, ASIO_MOVE_ARG(T4) x4, \
+  ASIO_MOVE_ARG(T5) x5
+
+# define ASIO_VARIADIC_MOVE_ARGS(n) \
+  ASIO_VARIADIC_MOVE_ARGS_##n
+
+# define ASIO_VARIADIC_MOVE_ARGS_1 \
+  ASIO_MOVE_CAST(T1)(x1)
+# define ASIO_VARIADIC_MOVE_ARGS_2 \
+  ASIO_MOVE_CAST(T1)(x1), ASIO_MOVE_CAST(T2)(x2)
+# define ASIO_VARIADIC_MOVE_ARGS_3 \
+  ASIO_MOVE_CAST(T1)(x1), ASIO_MOVE_CAST(T2)(x2), \
+  ASIO_MOVE_CAST(T3)(x3)
+# define ASIO_VARIADIC_MOVE_ARGS_4 \
+  ASIO_MOVE_CAST(T1)(x1), ASIO_MOVE_CAST(T2)(x2), \
+  ASIO_MOVE_CAST(T3)(x3), ASIO_MOVE_CAST(T4)(x4)
+# define ASIO_VARIADIC_MOVE_ARGS_5 \
+  ASIO_MOVE_CAST(T1)(x1), ASIO_MOVE_CAST(T2)(x2), \
+  ASIO_MOVE_CAST(T3)(x3), ASIO_MOVE_CAST(T4)(x4), \
+  ASIO_MOVE_CAST(T5)(x5)
+
+# define ASIO_VARIADIC_DECAY(n) \
+  ASIO_VARIADIC_DECAY_##n
+
+# define ASIO_VARIADIC_DECAY_1 \
+  typename decay<T1>::type
+# define ASIO_VARIADIC_DECAY_2 \
+  typename decay<T1>::type, typename decay<T2>::type
+# define ASIO_VARIADIC_DECAY_3 \
+  typename decay<T1>::type, typename decay<T2>::type, \
+  typename decay<T3>::type
+# define ASIO_VARIADIC_DECAY_4 \
+  typename decay<T1>::type, typename decay<T2>::type, \
+  typename decay<T3>::type, typename decay<T4>::type
+# define ASIO_VARIADIC_DECAY_5 \
+  typename decay<T1>::type, typename decay<T2>::type, \
+  typename decay<T3>::type, typename decay<T4>::type, \
+  typename decay<T5>::type
 
 # define ASIO_VARIADIC_GENERATE(m) m(1) m(2) m(3) m(4) m(5)
 
diff --git a/extern/include/asio/detail/wait_handler.hpp b/extern/include/asio/detail/wait_handler.hpp
index 998a0019..bd3dc244 100644
--- a/extern/include/asio/detail/wait_handler.hpp
+++ b/extern/include/asio/detail/wait_handler.hpp
@@ -2,7 +2,7 @@
 // detail/wait_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,12 +16,12 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/wait_op.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -38,17 +38,19 @@ class wait_handler : public wait_op
     : wait_op(&wait_handler::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(h))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     wait_handler* h(static_cast<wait_handler*>(base));
     ptr p = { asio::detail::addressof(h->handler_), h, h };
+    handler_work<Handler> w(h->handler_);
 
-    ASIO_HANDLER_COMPLETION((h));
+    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
@@ -66,7 +68,7 @@ class wait_handler : public wait_op
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/wait_op.hpp b/extern/include/asio/detail/wait_op.hpp
index a03d108f..1a3017ba 100644
--- a/extern/include/asio/detail/wait_op.hpp
+++ b/extern/include/asio/detail/wait_op.hpp
@@ -2,7 +2,7 @@
 // detail/wait_op.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/weak_ptr.hpp b/extern/include/asio/detail/weak_ptr.hpp
deleted file mode 100644
index 6b3f0aea..00000000
--- a/extern/include/asio/detail/weak_ptr.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// detail/weak_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WEAK_PTR_HPP
-#define ASIO_DETAIL_WEAK_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_STD_SHARED_PTR)
-# include <memory>
-#else // defined(ASIO_HAS_STD_SHARED_PTR)
-# include <boost/weak_ptr.hpp>
-#endif // defined(ASIO_HAS_STD_SHARED_PTR)
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_SHARED_PTR)
-using std::weak_ptr;
-#else // defined(ASIO_HAS_STD_SHARED_PTR)
-using boost::weak_ptr;
-#endif // defined(ASIO_HAS_STD_SHARED_PTR)
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_WEAK_PTR_HPP
diff --git a/extern/include/asio/detail/win_event.hpp b/extern/include/asio/detail/win_event.hpp
index f4170b99..859cdee7 100644
--- a/extern/include/asio/detail/win_event.hpp
+++ b/extern/include/asio/detail/win_event.hpp
@@ -2,7 +2,7 @@
 // detail/win_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -101,12 +101,37 @@ class win_event
     {
       state_ += 2;
       lock.unlock();
+#if defined(ASIO_WINDOWS_APP)
+      ::WaitForMultipleObjectsEx(2, events_, false, INFINITE, false);
+#else // defined(ASIO_WINDOWS_APP)
       ::WaitForMultipleObjects(2, events_, false, INFINITE);
+#endif // defined(ASIO_WINDOWS_APP)
       lock.lock();
       state_ -= 2;
     }
   }
 
+  // Timed wait for the event to become signalled.
+  template <typename Lock>
+  bool wait_for_usec(Lock& lock, long usec)
+  {
+    ASIO_ASSERT(lock.locked());
+    if ((state_ & 1) == 0)
+    {
+      state_ += 2;
+      lock.unlock();
+      DWORD msec = usec > 0 ? (usec < 1000 ? 1 : usec / 1000) : 0;
+#if defined(ASIO_WINDOWS_APP)
+      ::WaitForMultipleObjectsEx(2, events_, false, msec, false);
+#else // defined(ASIO_WINDOWS_APP)
+      ::WaitForMultipleObjects(2, events_, false, msec);
+#endif // defined(ASIO_WINDOWS_APP)
+      lock.lock();
+      state_ -= 2;
+    }
+    return (state_ & 1) != 0;
+  }
+
 private:
   HANDLE events_[2];
   std::size_t state_;
diff --git a/extern/include/asio/detail/win_fd_set_adapter.hpp b/extern/include/asio/detail/win_fd_set_adapter.hpp
index 4a05ce0b..8d5e700e 100644
--- a/extern/include/asio/detail/win_fd_set_adapter.hpp
+++ b/extern/include/asio/detail/win_fd_set_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/win_fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/win_fenced_block.hpp b/extern/include/asio/detail/win_fenced_block.hpp
index 610f22f4..1ce6e13b 100644
--- a/extern/include/asio/detail/win_fenced_block.hpp
+++ b/extern/include/asio/detail/win_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/win_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,7 @@
 #if defined(ASIO_WINDOWS) && !defined(UNDER_CE)
 
 #include "asio/detail/socket_types.hpp"
+#include "asio/detail/noncopyable.hpp"
 
 #include "asio/detail/push_options.hpp"
 
diff --git a/extern/include/asio/detail/win_global.hpp b/extern/include/asio/detail/win_global.hpp
new file mode 100644
index 00000000..3b15a32d
--- /dev/null
+++ b/extern/include/asio/detail/win_global.hpp
@@ -0,0 +1,73 @@
+//
+// detail/win_global.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_WIN_GLOBAL_HPP
+#define ASIO_DETAIL_WIN_GLOBAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/static_mutex.hpp"
+#include "asio/detail/tss_ptr.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+struct win_global_impl
+{
+  // Destructor automatically cleans up the global.
+  ~win_global_impl()
+  {
+    delete ptr_;
+  }
+
+  static win_global_impl instance_;
+  static static_mutex mutex_;
+  static T* ptr_;
+  static tss_ptr<T> tss_ptr_;
+};
+
+template <typename T>
+win_global_impl<T> win_global_impl<T>::instance_ = { 0 };
+
+template <typename T>
+static_mutex win_global_impl<T>::mutex_ = ASIO_STATIC_MUTEX_INIT;
+
+template <typename T>
+T* win_global_impl<T>::ptr_ = 0;
+
+template <typename T>
+tss_ptr<T> win_global_impl<T>::tss_ptr_;
+
+template <typename T>
+T& win_global()
+{
+  if (static_cast<T*>(win_global_impl<T>::tss_ptr_) == 0)
+  {
+    win_global_impl<T>::mutex_.init();
+    static_mutex::scoped_lock lock(win_global_impl<T>::mutex_);
+    win_global_impl<T>::ptr_ = new T;
+    win_global_impl<T>::tss_ptr_ = win_global_impl<T>::ptr_;
+  }
+
+  return *win_global_impl<T>::tss_ptr_;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_WIN_GLOBAL_HPP
diff --git a/extern/include/asio/detail/win_iocp_handle_read_op.hpp b/extern/include/asio/detail/win_iocp_handle_read_op.hpp
index 1cd92e7d..88e3f6c7 100644
--- a/extern/include/asio/detail/win_iocp_handle_read_op.hpp
+++ b/extern/include/asio/detail/win_iocp_handle_read_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_handle_read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -21,12 +21,12 @@
 #if defined(ASIO_HAS_IOCP)
 
 #include "asio/error.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -46,9 +46,10 @@ class win_iocp_handle_read_op : public operation
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t bytes_transferred)
   {
@@ -57,8 +58,9 @@ class win_iocp_handle_read_op : public operation
     // Take ownership of the operation object.
     win_iocp_handle_read_op* o(static_cast<win_iocp_handle_read_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
@@ -89,7 +91,7 @@ class win_iocp_handle_read_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_handle_service.hpp b/extern/include/asio/detail/win_iocp_handle_service.hpp
index 2e174e6a..849fe8f1 100644
--- a/extern/include/asio/detail/win_iocp_handle_service.hpp
+++ b/extern/include/asio/detail/win_iocp_handle_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -21,23 +21,24 @@
 #if defined(ASIO_HAS_IOCP)
 
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/cstdint.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/operation.hpp"
 #include "asio/detail/win_iocp_handle_read_op.hpp"
 #include "asio/detail/win_iocp_handle_write_op.hpp"
-#include "asio/detail/win_iocp_io_service.hpp"
+#include "asio/detail/win_iocp_io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-class win_iocp_handle_service
+class win_iocp_handle_service :
+  public service_base<win_iocp_handle_service>
 {
 public:
   // The native type of a stream handle.
@@ -74,10 +75,10 @@ class win_iocp_handle_service
     implementation_type* prev_;
   };
 
-  ASIO_DECL win_iocp_handle_service(asio::io_service& io_service);
+  ASIO_DECL win_iocp_handle_service(asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Construct a new handle implementation.
   ASIO_DECL void construct(implementation_type& impl);
@@ -148,11 +149,11 @@ class win_iocp_handle_service
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_write_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some"));
+    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
+          reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some"));
 
     start_write_op(impl, 0,
         buffer_sequence_adapter<asio::const_buffer,
@@ -169,11 +170,11 @@ class win_iocp_handle_service
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_write_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some_at"));
+    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
+          reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some_at"));
 
     start_write_op(impl, offset,
         buffer_sequence_adapter<asio::const_buffer,
@@ -210,11 +211,11 @@ class win_iocp_handle_service
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_read_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some"));
+    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
+          reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some"));
 
     start_read_op(impl, 0,
         buffer_sequence_adapter<asio::mutable_buffer,
@@ -232,11 +233,11 @@ class win_iocp_handle_service
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_read_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some_at"));
+    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
+          reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some_at"));
 
     start_read_op(impl, offset,
         buffer_sequence_adapter<asio::mutable_buffer,
@@ -299,7 +300,7 @@ class win_iocp_handle_service
 
   // The IOCP service used for running asynchronous operations and dispatching
   // handlers.
-  win_iocp_io_service& iocp_service_;
+  win_iocp_io_context& iocp_service_;
 
   // Mutex to protect access to the linked list of implementations.
   mutex mutex_;
diff --git a/extern/include/asio/detail/win_iocp_handle_write_op.hpp b/extern/include/asio/detail/win_iocp_handle_write_op.hpp
index 21edc58a..d7bb9443 100644
--- a/extern/include/asio/detail/win_iocp_handle_write_op.hpp
+++ b/extern/include/asio/detail/win_iocp_handle_write_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_handle_write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -21,12 +21,12 @@
 #if defined(ASIO_HAS_IOCP)
 
 #include "asio/error.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -45,16 +45,18 @@ class win_iocp_handle_write_op : public operation
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& ec, std::size_t bytes_transferred)
   {
     // Take ownership of the operation object.
     win_iocp_handle_write_op* o(static_cast<win_iocp_handle_write_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
@@ -81,7 +83,7 @@ class win_iocp_handle_write_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_io_service.hpp b/extern/include/asio/detail/win_iocp_io_context.hpp
similarity index 83%
rename from extern/include/asio/detail/win_iocp_io_service.hpp
rename to extern/include/asio/detail/win_iocp_io_context.hpp
index 9dfce08f..11bf58b7 100644
--- a/extern/include/asio/detail/win_iocp_io_service.hpp
+++ b/extern/include/asio/detail/win_iocp_io_context.hpp
@@ -1,15 +1,15 @@
 //
-// detail/win_iocp_io_service.hpp
+// detail/win_iocp_io_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
-#define ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
+#ifndef ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP
+#define ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -19,19 +19,19 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/io_service.hpp"
-#include "asio/detail/call_stack.hpp"
 #include "asio/detail/limits.hpp"
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/op_queue.hpp"
 #include "asio/detail/scoped_ptr.hpp"
 #include "asio/detail/socket_types.hpp"
 #include "asio/detail/thread.hpp"
+#include "asio/detail/thread_context.hpp"
 #include "asio/detail/timer_queue_base.hpp"
 #include "asio/detail/timer_queue_set.hpp"
 #include "asio/detail/wait_op.hpp"
 #include "asio/detail/win_iocp_operation.hpp"
 #include "asio/detail/win_iocp_thread_info.hpp"
+#include "asio/execution_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -40,18 +40,18 @@ namespace detail {
 
 class wait_op;
 
-class win_iocp_io_service
-  : public asio::detail::service_base<win_iocp_io_service>
+class win_iocp_io_context
+  : public execution_context_service_base<win_iocp_io_context>,
+    public thread_context
 {
 public:
-
   // Constructor. Specifies a concurrency hint that is passed through to the
   // underlying I/O completion port.
-  ASIO_DECL win_iocp_io_service(asio::io_service& io_service,
-      size_t concurrency_hint = 0);
+  ASIO_DECL win_iocp_io_context(asio::execution_context& ctx,
+      int concurrency_hint = -1);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Initialise the task. Nothing to do here.
   void init_task()
@@ -68,6 +68,9 @@ class win_iocp_io_service
   // Run until stopped or one operation is performed.
   ASIO_DECL size_t run_one(asio::error_code& ec);
 
+  // Run until timeout, interrupted, or one operation is performed.
+  ASIO_DECL size_t wait_one(long usec, asio::error_code& ec);
+
   // Poll for operations without blocking.
   ASIO_DECL size_t poll(asio::error_code& ec);
 
@@ -77,14 +80,14 @@ class win_iocp_io_service
   // Stop the event processing loop.
   ASIO_DECL void stop();
 
-  // Determine whether the io_service is stopped.
+  // Determine whether the io_context is stopped.
   bool stopped() const
   {
     return ::InterlockedExchangeAdd(&stopped_, 0) != 0;
   }
 
-  // Reset in preparation for a subsequent run invocation.
-  void reset()
+  // Restart in preparation for a subsequent run invocation.
+  void restart()
   {
     ::InterlockedExchange(&stopped_, 0);
   }
@@ -108,14 +111,6 @@ class win_iocp_io_service
     return thread_call_stack::contains(this) != 0;
   }
 
-  // Request invocation of the given handler.
-  template <typename Handler>
-  void dispatch(Handler& handler);
-
-  // Request invocation of the given handler and return immediately.
-  template <typename Handler>
-  void post(Handler& handler);
-
   // Request invocation of the given operation and return immediately. Assumes
   // that work_started() has not yet been called for the operation.
   void post_immediate_completion(win_iocp_operation* op, bool)
@@ -149,8 +144,15 @@ class win_iocp_io_service
     post_deferred_completion(op);
   }
 
-  // Process unfinished operations as part of a shutdown_service operation.
-  // Assumes that work_started() was previously called for the operations.
+  // Enqueue the given operation following a failed attempt to dispatch the
+  // operation for immediate invocation.
+  void do_dispatch(operation* op)
+  {
+    post_immediate_completion(op, false);
+  }
+
+  // Process unfinished operations as part of a shutdown operation. Assumes
+  // that work_started() was previously called for the operations.
   ASIO_DECL void abandon_operations(op_queue<operation>& ops);
 
   // Called after starting an overlapped I/O operation that did not complete
@@ -192,6 +194,18 @@ class win_iocp_io_service
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Move the timer operations associated with the given timer.
+  template <typename Time_Traits>
+  void move_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& to,
+      typename timer_queue<Time_Traits>::per_timer_data& from);
+
+  // Get the concurrency hint that was used to initialise the io_context.
+  int concurrency_hint() const
+  {
+    return concurrency_hint_;
+  }
+
 private:
 #if defined(WINVER) && (WINVER < 0x0500)
   typedef DWORD dword_ptr_t;
@@ -204,7 +218,7 @@ class win_iocp_io_service
   // Dequeues at most one operation from the I/O completion port, and then
   // executes it. Returns the number of operations that were dequeued (i.e.
   // either 0 or 1).
-  ASIO_DECL size_t do_one(bool block, asio::error_code& ec);
+  ASIO_DECL size_t do_one(DWORD msec, asio::error_code& ec);
 
   // Helper to calculate the GetQueuedCompletionStatus timeout.
   ASIO_DECL static DWORD get_gqcs_timeout();
@@ -295,9 +309,8 @@ class win_iocp_io_service
   // The operations that are ready to dispatch.
   op_queue<win_iocp_operation> completed_ops_;
 
-  // Per-thread call stack to track the state of each thread in the io_service.
-  typedef call_stack<win_iocp_io_service,
-      win_iocp_thread_info> thread_call_stack;
+  // The concurrency hint used to initialise the io_context.
+  const int concurrency_hint_;
 };
 
 } // namespace detail
@@ -305,11 +318,11 @@ class win_iocp_io_service
 
 #include "asio/detail/pop_options.hpp"
 
-#include "asio/detail/impl/win_iocp_io_service.hpp"
+#include "asio/detail/impl/win_iocp_io_context.hpp"
 #if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_iocp_io_service.ipp"
+# include "asio/detail/impl/win_iocp_io_context.ipp"
 #endif // defined(ASIO_HEADER_ONLY)
 
 #endif // defined(ASIO_HAS_IOCP)
 
-#endif // ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
+#endif // ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP
diff --git a/extern/include/asio/detail/win_iocp_null_buffers_op.hpp b/extern/include/asio/detail/win_iocp_null_buffers_op.hpp
index c7f1c41b..db70cb28 100644
--- a/extern/include/asio/detail/win_iocp_null_buffers_op.hpp
+++ b/extern/include/asio/detail/win_iocp_null_buffers_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_null_buffers_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/error.hpp"
@@ -47,14 +47,15 @@ class win_iocp_null_buffers_op : public reactor_op
       cancel_token_(cancel_token),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static bool do_perform(reactor_op*)
+  static status do_perform(reactor_op*)
   {
-    return true;
+    return done;
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t bytes_transferred)
   {
@@ -63,8 +64,9 @@ class win_iocp_null_buffers_op : public reactor_op
     // Take ownership of the operation object.
     win_iocp_null_buffers_op* o(static_cast<win_iocp_null_buffers_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
     // The reactor may have stored a result in the operation object.
     if (o->ec_)
@@ -99,7 +101,7 @@ class win_iocp_null_buffers_op : public reactor_op
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_operation.hpp b/extern/include/asio/detail/win_iocp_operation.hpp
index d30b1ba4..81d43f07 100644
--- a/extern/include/asio/detail/win_iocp_operation.hpp
+++ b/extern/include/asio/detail/win_iocp_operation.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -29,7 +29,7 @@
 namespace asio {
 namespace detail {
 
-class win_iocp_io_service;
+class win_iocp_io_context;
 
 // Base class for all operations. A function pointer is used instead of virtual
 // functions to avoid the associated overhead.
@@ -38,11 +38,12 @@ class win_iocp_operation
     ASIO_ALSO_INHERIT_TRACKED_HANDLER
 {
 public:
-  void complete(win_iocp_io_service& owner,
-      const asio::error_code& ec,
+  typedef win_iocp_operation operation_type;
+
+  void complete(void* owner, const asio::error_code& ec,
       std::size_t bytes_transferred)
   {
-    func_(&owner, this, ec, bytes_transferred);
+    func_(owner, this, ec, bytes_transferred);
   }
 
   void destroy()
@@ -52,7 +53,7 @@ class win_iocp_operation
 
 protected:
   typedef void (*func_type)(
-      win_iocp_io_service*, win_iocp_operation*,
+      void*, win_iocp_operation*,
       const asio::error_code&, std::size_t);
 
   win_iocp_operation(func_type func)
@@ -79,7 +80,7 @@ class win_iocp_operation
 
 private:
   friend class op_queue_access;
-  friend class win_iocp_io_service;
+  friend class win_iocp_io_context;
   win_iocp_operation* next_;
   func_type func_;
   long ready_;
diff --git a/extern/include/asio/detail/win_iocp_overlapped_op.hpp b/extern/include/asio/detail/win_iocp_overlapped_op.hpp
index 10252d16..2b2cc319 100644
--- a/extern/include/asio/detail/win_iocp_overlapped_op.hpp
+++ b/extern/include/asio/detail/win_iocp_overlapped_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_overlapped_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,11 +20,11 @@
 #if defined(ASIO_HAS_IOCP)
 
 #include "asio/error.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -42,16 +42,18 @@ class win_iocp_overlapped_op : public operation
     : operation(&win_iocp_overlapped_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& ec, std::size_t bytes_transferred)
   {
     // Take ownership of the operation object.
     win_iocp_overlapped_op* o(static_cast<win_iocp_overlapped_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -69,7 +71,7 @@ class win_iocp_overlapped_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_overlapped_ptr.hpp b/extern/include/asio/detail/win_iocp_overlapped_ptr.hpp
index ae2aee8a..7a191143 100644
--- a/extern/include/asio/detail/win_iocp_overlapped_ptr.hpp
+++ b/extern/include/asio/detail/win_iocp_overlapped_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_overlapped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/io_service.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/win_iocp_overlapped_op.hpp"
-#include "asio/detail/win_iocp_io_service.hpp"
+#include "asio/detail/win_iocp_io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -46,11 +46,11 @@ class win_iocp_overlapped_ptr
   // Construct an win_iocp_overlapped_ptr to contain the specified handler.
   template <typename Handler>
   explicit win_iocp_overlapped_ptr(
-      asio::io_service& io_service, ASIO_MOVE_ARG(Handler) handler)
+      asio::io_context& io_context, ASIO_MOVE_ARG(Handler) handler)
     : ptr_(0),
       iocp_service_(0)
   {
-    this->reset(io_service, ASIO_MOVE_CAST(Handler)(handler));
+    this->reset(io_context, ASIO_MOVE_CAST(Handler)(handler));
   }
 
   // Destructor automatically frees the OVERLAPPED object unless released.
@@ -74,22 +74,21 @@ class win_iocp_overlapped_ptr
   // Reset to contain the specified handler, freeing any current OVERLAPPED
   // object.
   template <typename Handler>
-  void reset(asio::io_service& io_service, Handler handler)
+  void reset(asio::io_context& io_context, Handler handler)
   {
     typedef win_iocp_overlapped_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "io_service",
-          &io_service.impl_, "overlapped"));
+    ASIO_HANDLER_CREATION((io_context, *p.p,
+          "io_context", &io_context.impl_, 0, "overlapped"));
 
-    io_service.impl_.work_started();
+    io_context.impl_.work_started();
     reset();
     ptr_ = p.p;
     p.v = p.p = 0;
-    iocp_service_ = &io_service.impl_;
+    iocp_service_ = &io_context.impl_;
   }
 
   // Get the contained OVERLAPPED object.
@@ -131,7 +130,7 @@ class win_iocp_overlapped_ptr
 
 private:
   win_iocp_operation* ptr_;
-  win_iocp_io_service* iocp_service_;
+  win_iocp_io_context* iocp_service_;
 };
 
 } // namespace detail
diff --git a/extern/include/asio/detail/win_iocp_serial_port_service.hpp b/extern/include/asio/detail/win_iocp_serial_port_service.hpp
index 2bfdcc50..ac06348e 100644
--- a/extern/include/asio/detail/win_iocp_serial_port_service.hpp
+++ b/extern/include/asio/detail/win_iocp_serial_port_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_serial_port_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -22,7 +22,7 @@
 
 #include <string>
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/win_iocp_handle_service.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -31,7 +31,8 @@ namespace asio {
 namespace detail {
 
 // Extend win_iocp_handle_service to provide serial port support.
-class win_iocp_serial_port_service
+class win_iocp_serial_port_service :
+  public service_base<win_iocp_serial_port_service>
 {
 public:
   // The native type of a serial port.
@@ -42,10 +43,10 @@ class win_iocp_serial_port_service
 
   // Constructor.
   ASIO_DECL win_iocp_serial_port_service(
-      asio::io_service& io_service);
+      asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Construct a new serial port implementation.
   void construct(implementation_type& impl)
@@ -184,8 +185,8 @@ class win_iocp_serial_port_service
   static asio::error_code store_option(const void* option,
       ::DCB& storage, asio::error_code& ec)
   {
-    return static_cast<const SettableSerialPortOption*>(option)->store(
-        storage, ec);
+    static_cast<const SettableSerialPortOption*>(option)->store(storage, ec);
+    return ec;
   }
 
   // Helper function to set a serial port option.
@@ -202,7 +203,8 @@ class win_iocp_serial_port_service
   static asio::error_code load_option(void* option,
       const ::DCB& storage, asio::error_code& ec)
   {
-    return static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
+    static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
+    return ec;
   }
 
   // Helper function to get a serial port option.
diff --git a/extern/include/asio/detail/win_iocp_socket_accept_op.hpp b/extern/include/asio/detail/win_iocp_socket_accept_op.hpp
index a10d04df..18e73356 100644
--- a/extern/include/asio/detail/win_iocp_socket_accept_op.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_accept_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_accept_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/detail/win_iocp_socket_service_base.hpp"
@@ -54,6 +54,7 @@ class win_iocp_socket_accept_op : public operation
       enable_connection_aborted_(enable_connection_aborted),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
   socket_holder& new_socket()
@@ -71,7 +72,7 @@ class win_iocp_socket_accept_op : public operation
     return sizeof(sockaddr_storage_type) + 16;
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t /*bytes_transferred*/)
   {
@@ -80,6 +81,7 @@ class win_iocp_socket_accept_op : public operation
     // Take ownership of the operation object.
     win_iocp_socket_accept_op* o(static_cast<win_iocp_socket_accept_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
     if (owner)
     {
@@ -120,7 +122,7 @@ class win_iocp_socket_accept_op : public operation
         *o->peer_endpoint_ = peer_endpoint;
     }
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -138,7 +140,7 @@ class win_iocp_socket_accept_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
@@ -155,6 +157,136 @@ class win_iocp_socket_accept_op : public operation
   Handler handler_;
 };
 
+#if defined(ASIO_HAS_MOVE)
+
+template <typename Protocol, typename Handler>
+class win_iocp_socket_move_accept_op : public operation
+{
+public:
+  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_move_accept_op);
+
+  win_iocp_socket_move_accept_op(
+      win_iocp_socket_service_base& socket_service, socket_type socket,
+      const Protocol& protocol, asio::io_context& peer_io_context,
+      typename Protocol::endpoint* peer_endpoint,
+      bool enable_connection_aborted, Handler& handler)
+    : operation(&win_iocp_socket_move_accept_op::do_complete),
+      socket_service_(socket_service),
+      socket_(socket),
+      peer_(peer_io_context),
+      protocol_(protocol),
+      peer_endpoint_(peer_endpoint),
+      enable_connection_aborted_(enable_connection_aborted),
+      handler_(ASIO_MOVE_CAST(Handler)(handler))
+  {
+    handler_work<Handler>::start(handler_);
+  }
+
+  socket_holder& new_socket()
+  {
+    return new_socket_;
+  }
+
+  void* output_buffer()
+  {
+    return output_buffer_;
+  }
+
+  DWORD address_length()
+  {
+    return sizeof(sockaddr_storage_type) + 16;
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const asio::error_code& result_ec,
+      std::size_t /*bytes_transferred*/)
+  {
+    asio::error_code ec(result_ec);
+
+    // Take ownership of the operation object.
+    win_iocp_socket_move_accept_op* o(
+        static_cast<win_iocp_socket_move_accept_op*>(base));
+    ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
+
+    if (owner)
+    {
+      typename Protocol::endpoint peer_endpoint;
+      std::size_t addr_len = peer_endpoint.capacity();
+      socket_ops::complete_iocp_accept(o->socket_,
+          o->output_buffer(), o->address_length(),
+          peer_endpoint.data(), &addr_len,
+          o->new_socket_.get(), ec);
+
+      // Restart the accept operation if we got the connection_aborted error
+      // and the enable_connection_aborted socket option is not set.
+      if (ec == asio::error::connection_aborted
+          && !o->enable_connection_aborted_)
+      {
+        o->reset();
+        o->socket_service_.restart_accept_op(o->socket_,
+            o->new_socket_, o->protocol_.family(),
+            o->protocol_.type(), o->protocol_.protocol(),
+            o->output_buffer(), o->address_length(), o);
+        p.v = p.p = 0;
+        return;
+      }
+
+      // If the socket was successfully accepted, transfer ownership of the
+      // socket to the peer object.
+      if (!ec)
+      {
+        o->peer_.assign(o->protocol_,
+            typename Protocol::socket::native_handle_type(
+              o->new_socket_.get(), peer_endpoint), ec);
+        if (!ec)
+          o->new_socket_.release();
+      }
+
+      // Pass endpoint back to caller.
+      if (o->peer_endpoint_)
+        *o->peer_endpoint_ = peer_endpoint;
+    }
+
+    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::move_binder2<Handler,
+      asio::error_code, typename Protocol::socket>
+        handler(0, ASIO_MOVE_CAST(Handler)(o->handler_), ec,
+          ASIO_MOVE_CAST(typename Protocol::socket)(o->peer_));
+    p.h = asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+      w.complete(handler, handler.handler_);
+      ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  win_iocp_socket_service_base& socket_service_;
+  socket_type socket_;
+  socket_holder new_socket_;
+  typename Protocol::socket peer_;
+  Protocol protocol_;
+  typename Protocol::endpoint* peer_endpoint_;
+  unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
+  bool enable_connection_aborted_;
+  Handler handler_;
+};
+
+#endif // defined(ASIO_HAS_MOVE)
+
 } // namespace detail
 } // namespace asio
 
diff --git a/extern/include/asio/detail/win_iocp_socket_connect_op.hpp b/extern/include/asio/detail/win_iocp_socket_connect_op.hpp
index 9c617475..e0c52dc9 100644
--- a/extern/include/asio/detail/win_iocp_socket_connect_op.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_connect_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_connect_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,11 +19,11 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/error.hpp"
@@ -43,12 +43,13 @@ class win_iocp_socket_connect_op_base : public reactor_op
   {
   }
 
-  static bool do_perform(reactor_op* base)
+  static status do_perform(reactor_op* base)
   {
     win_iocp_socket_connect_op_base* o(
         static_cast<win_iocp_socket_connect_op_base*>(base));
 
-    return socket_ops::non_blocking_connect(o->socket_, o->ec_);
+    return socket_ops::non_blocking_connect(
+        o->socket_, o->ec_) ? done : not_done;
   }
 
   socket_type socket_;
@@ -66,9 +67,10 @@ class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base
         &win_iocp_socket_connect_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t /*bytes_transferred*/)
   {
@@ -78,6 +80,7 @@ class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base
     win_iocp_socket_connect_op* o(
         static_cast<win_iocp_socket_connect_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
     if (owner)
     {
@@ -87,7 +90,7 @@ class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base
         ec = o->ec_;
     }
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -105,7 +108,7 @@ class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_socket_recv_op.hpp b/extern/include/asio/detail/win_iocp_socket_recv_op.hpp
index 86667f02..41595405 100644
--- a/extern/include/asio/detail/win_iocp_socket_recv_op.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_recv_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/error.hpp"
@@ -49,9 +49,10 @@ class win_iocp_socket_recv_op : public operation
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t bytes_transferred)
   {
@@ -60,8 +61,9 @@ class win_iocp_socket_recv_op : public operation
     // Take ownership of the operation object.
     win_iocp_socket_recv_op* o(static_cast<win_iocp_socket_recv_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
@@ -93,7 +95,7 @@ class win_iocp_socket_recv_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_socket_recvfrom_op.hpp b/extern/include/asio/detail/win_iocp_socket_recvfrom_op.hpp
index e522d7e3..843ce5bb 100644
--- a/extern/include/asio/detail/win_iocp_socket_recvfrom_op.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_recvfrom_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_recvfrom_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/error.hpp"
@@ -50,6 +50,7 @@ class win_iocp_socket_recvfrom_op : public operation
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
   int& endpoint_size()
@@ -57,7 +58,7 @@ class win_iocp_socket_recvfrom_op : public operation
     return endpoint_size_;
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t bytes_transferred)
   {
@@ -67,8 +68,9 @@ class win_iocp_socket_recvfrom_op : public operation
     win_iocp_socket_recvfrom_op* o(
         static_cast<win_iocp_socket_recvfrom_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
@@ -100,7 +102,7 @@ class win_iocp_socket_recvfrom_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_socket_recvmsg_op.hpp b/extern/include/asio/detail/win_iocp_socket_recvmsg_op.hpp
index b78741b2..78f36b7f 100644
--- a/extern/include/asio/detail/win_iocp_socket_recvmsg_op.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_recvmsg_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_recvmsg_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/error.hpp"
@@ -51,9 +51,10 @@ class win_iocp_socket_recvmsg_op : public operation
       out_flags_(out_flags),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t bytes_transferred)
   {
@@ -63,8 +64,9 @@ class win_iocp_socket_recvmsg_op : public operation
     win_iocp_socket_recvmsg_op* o(
         static_cast<win_iocp_socket_recvmsg_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
@@ -94,7 +96,7 @@ class win_iocp_socket_recvmsg_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_socket_send_op.hpp b/extern/include/asio/detail/win_iocp_socket_send_op.hpp
index e40c71ce..e1c7ab93 100644
--- a/extern/include/asio/detail/win_iocp_socket_send_op.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_send_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_HAS_IOCP)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/operation.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/error.hpp"
@@ -47,9 +47,10 @@ class win_iocp_socket_send_op : public operation
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code& result_ec,
       std::size_t bytes_transferred)
   {
@@ -58,8 +59,9 @@ class win_iocp_socket_send_op : public operation
     // Take ownership of the operation object.
     win_iocp_socket_send_op* o(static_cast<win_iocp_socket_send_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
@@ -88,7 +90,7 @@ class win_iocp_socket_send_op : public operation
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/win_iocp_socket_service.hpp b/extern/include/asio/detail/win_iocp_socket_service.hpp
index 76326911..3f01b4d3 100644
--- a/extern/include/asio/detail/win_iocp_socket_service.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,22 +21,22 @@
 
 #include <cstring>
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/socket_base.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/operation.hpp"
-#include "asio/detail/reactor.hpp"
 #include "asio/detail/reactor_op.hpp"
+#include "asio/detail/select_reactor.hpp"
 #include "asio/detail/socket_holder.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/detail/socket_types.hpp"
-#include "asio/detail/win_iocp_io_service.hpp"
+#include "asio/detail/win_iocp_io_context.hpp"
 #include "asio/detail/win_iocp_null_buffers_op.hpp"
 #include "asio/detail/win_iocp_socket_accept_op.hpp"
 #include "asio/detail/win_iocp_socket_connect_op.hpp"
@@ -50,7 +50,9 @@ namespace asio {
 namespace detail {
 
 template <typename Protocol>
-class win_iocp_socket_service : public win_iocp_socket_service_base
+class win_iocp_socket_service :
+  public service_base<win_iocp_socket_service<Protocol> >,
+  public win_iocp_socket_service_base
 {
 public:
   // The protocol type.
@@ -127,11 +129,18 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
   };
 
   // Constructor.
-  win_iocp_socket_service(asio::io_service& io_service)
-    : win_iocp_socket_service_base(io_service)
+  win_iocp_socket_service(asio::io_context& io_context)
+    : service_base<win_iocp_socket_service<Protocol> >(io_context),
+      win_iocp_socket_service_base(io_context)
   {
   }
 
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown()
+  {
+    this->base_shutdown();
+  }
+
   // Move-construct a new socket implementation.
   void move_construct(implementation_type& impl,
       implementation_type& other_impl)
@@ -168,6 +177,7 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
   // Move-construct a new socket implementation from another protocol type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      win_iocp_socket_service<Protocol1>&,
       typename win_iocp_socket_service<
         Protocol1>::implementation_type& other_impl)
   {
@@ -277,6 +287,14 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     return endpoint;
   }
 
+  // Disable sends or receives on the socket.
+  asio::error_code shutdown(base_implementation_type& impl,
+      socket_base::shutdown_type what, asio::error_code& ec)
+  {
+    socket_ops::shutdown(impl.socket_, what, ec);
+    return ec;
+  }
+
   // Send a datagram to the specified endpoint. Returns the number of bytes
   // sent.
   template <typename ConstBufferSequence>
@@ -298,7 +316,7 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
       asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
 
     return 0;
   }
@@ -313,11 +331,11 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_send_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_send_to"));
 
     buffer_sequence_adapter<asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
@@ -336,14 +354,13 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_send_to(null_buffers)"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_send_to(null_buffers)"));
 
-    start_reactor_op(impl, reactor::write_op, p.p);
+    start_reactor_op(impl, select_reactor::write_op, p.p);
     p.v = p.p = 0;
   }
 
@@ -375,7 +392,7 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
       socket_base::message_flags, asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
 
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
@@ -395,11 +412,11 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     typedef win_iocp_socket_recvfrom_op<
       MutableBufferSequence, endpoint_type, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(sender_endp, impl.cancel_token_, buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_from"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_receive_from"));
 
     buffer_sequence_adapter<asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
@@ -418,12 +435,11 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl,
-          "async_receive_from(null_buffers)"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_receive_from(null_buffers)"));
 
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
@@ -454,13 +470,42 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     {
       if (peer_endpoint)
         peer_endpoint->resize(addr_len);
-      if (!peer.assign(impl.protocol_, new_socket.get(), ec))
+      peer.assign(impl.protocol_, new_socket.get(), ec);
+      if (!ec)
         new_socket.release();
     }
 
     return ec;
   }
 
+#if defined(ASIO_HAS_MOVE)
+  // Accept a new connection.
+  typename Protocol::socket accept(implementation_type& impl,
+      io_context* peer_io_context, endpoint_type* peer_endpoint,
+      asio::error_code& ec)
+  {
+    typename Protocol::socket peer(
+        peer_io_context ? *peer_io_context : io_context_);
+
+    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
+    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
+          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
+          peer_endpoint ? &addr_len : 0, ec));
+
+    // On success, assign new connection to peer socket object.
+    if (new_socket.get() != invalid_socket)
+    {
+      if (peer_endpoint)
+        peer_endpoint->resize(addr_len);
+      peer.assign(impl.protocol_, new_socket.get(), ec);
+      if (!ec)
+        new_socket.release();
+    }
+
+    return peer;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   // Start an asynchronous accept. The peer and peer_endpoint objects
   // must be valid until the accept's handler is invoked.
   template <typename Socket, typename Handler>
@@ -470,14 +515,14 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_accept_op<Socket, protocol_type, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     bool enable_connection_aborted =
       (impl.state_ & socket_ops::enable_connection_aborted) != 0;
     p.p = new (p.v) op(*this, impl.socket_, peer, impl.protocol_,
         peer_endpoint, enable_connection_aborted, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_accept"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_accept"));
 
     start_accept_op(impl, peer.is_open(), p.p->new_socket(),
         impl.protocol_.family(), impl.protocol_.type(),
@@ -486,6 +531,35 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     p.v = p.p = 0;
   }
 
+#if defined(ASIO_HAS_MOVE)
+  // Start an asynchronous accept. The peer and peer_endpoint objects
+  // must be valid until the accept's handler is invoked.
+  template <typename Handler>
+  void async_accept(implementation_type& impl,
+      asio::io_context* peer_io_context,
+      endpoint_type* peer_endpoint, Handler& handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef win_iocp_socket_move_accept_op<protocol_type, Handler> op;
+    typename op::ptr p = { asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    bool enable_connection_aborted =
+      (impl.state_ & socket_ops::enable_connection_aborted) != 0;
+    p.p = new (p.v) op(*this, impl.socket_, impl.protocol_,
+        peer_io_context ? *peer_io_context : io_context_,
+        peer_endpoint, enable_connection_aborted, handler);
+
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_accept"));
+
+    start_accept_op(impl, false, p.p->new_socket(),
+        impl.protocol_.family(), impl.protocol_.type(),
+        impl.protocol_.protocol(), p.p->output_buffer(),
+        p.p->address_length(), p.p);
+    p.v = p.p = 0;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
   // Connect the socket to the specified endpoint.
   asio::error_code connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, asio::error_code& ec)
@@ -503,11 +577,11 @@ class win_iocp_socket_service : public win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_connect_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.socket_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_connect"));
 
     start_connect_op(impl, impl.protocol_.family(), impl.protocol_.type(),
         peer_endpoint.data(), static_cast<int>(peer_endpoint.size()), p.p);
diff --git a/extern/include/asio/detail/win_iocp_socket_service_base.hpp b/extern/include/asio/detail/win_iocp_socket_service_base.hpp
index 27bad7c5..ef1d7180 100644
--- a/extern/include/asio/detail/win_iocp_socket_service_base.hpp
+++ b/extern/include/asio/detail/win_iocp_socket_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,27 +20,28 @@
 #if defined(ASIO_HAS_IOCP)
 
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/socket_base.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/operation.hpp"
-#include "asio/detail/reactor.hpp"
 #include "asio/detail/reactor_op.hpp"
+#include "asio/detail/select_reactor.hpp"
 #include "asio/detail/socket_holder.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/detail/socket_types.hpp"
-#include "asio/detail/win_iocp_io_service.hpp"
+#include "asio/detail/win_iocp_io_context.hpp"
 #include "asio/detail/win_iocp_null_buffers_op.hpp"
 #include "asio/detail/win_iocp_socket_connect_op.hpp"
 #include "asio/detail/win_iocp_socket_send_op.hpp"
 #include "asio/detail/win_iocp_socket_recv_op.hpp"
 #include "asio/detail/win_iocp_socket_recvmsg_op.hpp"
+#include "asio/detail/win_iocp_wait_op.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -68,7 +69,7 @@ class win_iocp_socket_service_base
     socket_ops::shared_cancel_token_type cancel_token_;
 
     // Per-descriptor data used by the reactor.
-    reactor::per_descriptor_data reactor_data_;
+    select_reactor::per_descriptor_data reactor_data_;
 
 #if defined(ASIO_ENABLE_CANCELIO)
     // The ID of the thread from which it is safe to cancel asynchronous
@@ -85,10 +86,10 @@ class win_iocp_socket_service_base
 
   // Constructor.
   ASIO_DECL win_iocp_socket_service_base(
-      asio::io_service& io_service);
+      asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void base_shutdown();
 
   // Construct a new socket implementation.
   ASIO_DECL void construct(base_implementation_type& impl);
@@ -115,6 +116,10 @@ class win_iocp_socket_service_base
   ASIO_DECL asio::error_code close(
       base_implementation_type& impl, asio::error_code& ec);
 
+  // Release ownership of the socket.
+  ASIO_DECL socket_type release(
+      base_implementation_type& impl, asio::error_code& ec);
+
   // Cancel all operations associated with the socket.
   ASIO_DECL asio::error_code cancel(
       base_implementation_type& impl, asio::error_code& ec);
@@ -179,14 +184,68 @@ class win_iocp_socket_service_base
     return ec;
   }
 
-  // Disable sends or receives on the socket.
-  asio::error_code shutdown(base_implementation_type& impl,
-      socket_base::shutdown_type what, asio::error_code& ec)
+  // Wait for the socket to become ready to read, ready to write, or to have
+  // pending error conditions.
+  asio::error_code wait(base_implementation_type& impl,
+      socket_base::wait_type w, asio::error_code& ec)
   {
-    socket_ops::shutdown(impl.socket_, what, ec);
+    switch (w)
+    {
+    case socket_base::wait_read:
+      socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
+      break;
+    case socket_base::wait_write:
+      socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
+      break;
+    case socket_base::wait_error:
+      socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
+      break;
+    default:
+      ec = asio::error::invalid_argument;
+      break;
+    }
+
     return ec;
   }
 
+  // Asynchronously wait for the socket to become ready to read, ready to
+  // write, or to have pending error conditions.
+  template <typename Handler>
+  void async_wait(base_implementation_type& impl,
+      socket_base::wait_type w, Handler& handler)
+  {
+    bool is_continuation =
+      asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef win_iocp_wait_op<Handler> op;
+    typename op::ptr p = { asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(impl.cancel_token_, handler);
+
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_wait"));
+
+    switch (w)
+    {
+      case socket_base::wait_read:
+        start_null_buffers_receive_op(impl, 0, p.p);
+        break;
+      case socket_base::wait_write:
+        start_reactor_op(impl, select_reactor::write_op, p.p);
+        break;
+      case socket_base::wait_error:
+        start_reactor_op(impl, select_reactor::except_op, p.p);
+        break;
+      default:
+        p.p->ec_ = asio::error::invalid_argument;
+        iocp_service_.post_immediate_completion(p.p, is_continuation);
+        break;
+    }
+
+    p.v = p.p = 0;
+  }
+
   // Send the given data to the peer. Returns the number of bytes sent.
   template <typename ConstBufferSequence>
   size_t send(base_implementation_type& impl,
@@ -205,7 +264,7 @@ class win_iocp_socket_service_base
       socket_base::message_flags, asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
 
     return 0;
   }
@@ -220,11 +279,11 @@ class win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_send_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_send"));
 
     buffer_sequence_adapter<asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
@@ -243,14 +302,13 @@ class win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_send(null_buffers)"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_send(null_buffers)"));
 
-    start_reactor_op(impl, reactor::write_op, p.p);
+    start_reactor_op(impl, select_reactor::write_op, p.p);
     p.v = p.p = 0;
   }
 
@@ -272,7 +330,7 @@ class win_iocp_socket_service_base
       socket_base::message_flags, asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
 
     return 0;
   }
@@ -287,11 +345,11 @@ class win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recv_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.state_, impl.cancel_token_, buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_receive"));
 
     buffer_sequence_adapter<asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
@@ -310,12 +368,11 @@ class win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_receive(null_buffers)"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_receive(null_buffers)"));
 
     start_null_buffers_receive_op(impl, flags, p.p);
     p.v = p.p = 0;
@@ -342,7 +399,7 @@ class win_iocp_socket_service_base
       socket_base::message_flags& out_flags, asio::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
 
     // Clear out_flags, since we cannot give it any other sensible value when
     // performing a null_buffers operation.
@@ -361,12 +418,11 @@ class win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recvmsg_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, out_flags, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket",
-          &impl, "async_receive_with_flags"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_receive_with_flags"));
 
     buffer_sequence_adapter<asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
@@ -384,12 +440,11 @@ class win_iocp_socket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl,
-          "async_receive_with_flags(null_buffers)"));
+    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
+          &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
 
     // Reset out_flags since it can be given no sensible value at this time.
     out_flags = 0;
@@ -463,9 +518,9 @@ class win_iocp_socket_service_base
       base_implementation_type& impl);
 
   // Helper function to get the reactor. If no reactor has been created yet, a
-  // new one is obtained from the io_service and a pointer to it is cached in
+  // new one is obtained from the io_context and a pointer to it is cached in
   // this service.
-  ASIO_DECL reactor& get_reactor();
+  ASIO_DECL select_reactor& get_reactor();
 
   // The type of a ConnectEx function pointer, as old SDKs may not provide it.
   typedef BOOL (PASCAL *connect_ex_fn)(SOCKET,
@@ -477,6 +532,15 @@ class win_iocp_socket_service_base
   ASIO_DECL connect_ex_fn get_connect_ex(
       base_implementation_type& impl, int type);
 
+  // The type of a NtSetInformationFile function pointer.
+  typedef LONG (NTAPI *nt_set_info_fn)(HANDLE, ULONG_PTR*, void*, ULONG, ULONG);
+
+  // Helper function to get the NtSetInformationFile function pointer. If no
+  // NtSetInformationFile pointer has been obtained yet, one is obtained using
+  // GetProcAddress and the pointer is cached. Returns a null pointer if
+  // NtSetInformationFile is not available.
+  ASIO_DECL nt_set_info_fn get_nt_set_info();
+
   // Helper function to emulate InterlockedCompareExchangePointer functionality
   // for:
   // - very old Platform SDKs; and
@@ -489,20 +553,23 @@ class win_iocp_socket_service_base
   // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
   ASIO_DECL void* interlocked_exchange_pointer(void** dest, void* val);
 
-  // The io_service used to obtain the reactor, if required.
-  asio::io_service& io_service_;
+  // The io_context used to obtain the reactor, if required.
+  asio::io_context& io_context_;
 
   // The IOCP service used for running asynchronous operations and dispatching
   // handlers.
-  win_iocp_io_service& iocp_service_;
+  win_iocp_io_context& iocp_service_;
 
   // The reactor used for performing connect operations. This object is created
   // only if needed.
-  reactor* reactor_;
+  select_reactor* reactor_;
 
   // Pointer to ConnectEx implementation.
   void* connect_ex_;
 
+  // Pointer to NtSetInformationFile implementation.
+  void* nt_set_info_;
+
   // Mutex to protect access to the linked list of implementations. 
   asio::detail::mutex mutex_;
 
diff --git a/extern/include/asio/detail/win_iocp_thread_info.hpp b/extern/include/asio/detail/win_iocp_thread_info.hpp
index 2b698d83..13181e2e 100644
--- a/extern/include/asio/detail/win_iocp_thread_info.hpp
+++ b/extern/include/asio/detail/win_iocp_thread_info.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_thread_info.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/win_iocp_wait_op.hpp b/extern/include/asio/detail/win_iocp_wait_op.hpp
new file mode 100644
index 00000000..472eea38
--- /dev/null
+++ b/extern/include/asio/detail/win_iocp_wait_op.hpp
@@ -0,0 +1,121 @@
+//
+// detail/win_iocp_wait_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP
+#define ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_IOCP)
+
+#include "asio/detail/bind_handler.hpp"
+#include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/reactor_op.hpp"
+#include "asio/detail/socket_ops.hpp"
+#include "asio/error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Handler>
+class win_iocp_wait_op : public reactor_op
+{
+public:
+  ASIO_DEFINE_HANDLER_PTR(win_iocp_wait_op);
+
+  win_iocp_wait_op(socket_ops::weak_cancel_token_type cancel_token,
+      Handler& handler)
+    : reactor_op(&win_iocp_wait_op::do_perform,
+        &win_iocp_wait_op::do_complete),
+      cancel_token_(cancel_token),
+      handler_(ASIO_MOVE_CAST(Handler)(handler))
+  {
+    handler_work<Handler>::start(handler_);
+  }
+
+  static status do_perform(reactor_op*)
+  {
+    return done;
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const asio::error_code& result_ec,
+      std::size_t /*bytes_transferred*/)
+  {
+    asio::error_code ec(result_ec);
+
+    // Take ownership of the operation object.
+    win_iocp_wait_op* o(static_cast<win_iocp_wait_op*>(base));
+    ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
+
+    ASIO_HANDLER_COMPLETION((*o));
+
+    // The reactor may have stored a result in the operation object.
+    if (o->ec_)
+      ec = o->ec_;
+
+    // Map non-portable errors to their portable counterparts.
+    if (ec.value() == ERROR_NETNAME_DELETED)
+    {
+      if (o->cancel_token_.expired())
+        ec = asio::error::operation_aborted;
+      else
+        ec = asio::error::connection_reset;
+    }
+    else if (ec.value() == ERROR_PORT_UNREACHABLE)
+    {
+      ec = asio::error::connection_refused;
+    }
+
+    // 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::binder1<Handler, asio::error_code>
+      handler(o->handler_, ec);
+    p.h = asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      w.complete(handler, handler.handler_);
+      ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  socket_ops::weak_cancel_token_type cancel_token_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_IOCP)
+
+#endif // ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP
diff --git a/extern/include/asio/detail/win_mutex.hpp b/extern/include/asio/detail/win_mutex.hpp
index dd393dec..ce52a2f7 100644
--- a/extern/include/asio/detail/win_mutex.hpp
+++ b/extern/include/asio/detail/win_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/win_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/win_object_handle_service.hpp b/extern/include/asio/detail/win_object_handle_service.hpp
index d1d2fc25..1d8abc9c 100644
--- a/extern/include/asio/detail/win_object_handle_service.hpp
+++ b/extern/include/asio/detail/win_object_handle_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_object_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -20,18 +20,19 @@
 
 #if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/wait_handler.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-class win_object_handle_service
+class win_object_handle_service :
+  public service_base<win_object_handle_service>
 {
 public:
   // The native type of an object handle.
@@ -79,10 +80,10 @@ class win_object_handle_service
 
   // Constructor.
   ASIO_DECL win_object_handle_service(
-      asio::io_service& io_service);
+      asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Construct a new handle implementation.
   ASIO_DECL void construct(implementation_type& impl);
@@ -134,11 +135,11 @@ class win_object_handle_service
     // Allocate and construct an operation to wrap the handler.
     typedef wait_handler<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "object_handle", &impl, "async_wait"));
+    ASIO_HANDLER_CREATION((io_context_.context(), *p.p, "object_handle",
+          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "async_wait"));
 
     start_wait_op(impl, p.p);
     p.v = p.p = 0;
@@ -156,8 +157,8 @@ class win_object_handle_service
   static ASIO_DECL VOID CALLBACK wait_callback(
       PVOID param, BOOLEAN timeout);
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
+  // The io_context implementation used to post completions.
+  io_context_impl& io_context_;
 
   // Mutex to protect access to internal state.
   mutex mutex_;
diff --git a/extern/include/asio/detail/win_static_mutex.hpp b/extern/include/asio/detail/win_static_mutex.hpp
index b4ff6ce3..b1696886 100644
--- a/extern/include/asio/detail/win_static_mutex.hpp
+++ b/extern/include/asio/detail/win_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/win_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/win_thread.hpp b/extern/include/asio/detail/win_thread.hpp
index 42868141..8b28a90b 100644
--- a/extern/include/asio/detail/win_thread.hpp
+++ b/extern/include/asio/detail/win_thread.hpp
@@ -2,7 +2,7 @@
 // detail/win_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,8 +17,11 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_WINDOWS) && !defined(UNDER_CE)
+#if defined(ASIO_WINDOWS) \
+  && !defined(ASIO_WINDOWS_APP) \
+  && !defined(UNDER_CE)
 
+#include <cstddef>
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/socket_types.hpp"
 
@@ -76,6 +79,9 @@ class win_thread
   // Wait for the thread to exit.
   ASIO_DECL void join();
 
+  // Get number of CPUs.
+  ASIO_DECL static std::size_t hardware_concurrency();
+
 private:
   friend ASIO_DECL unsigned int __stdcall win_thread_function(void* arg);
 
@@ -134,6 +140,8 @@ class win_thread
 # include "asio/detail/impl/win_thread.ipp"
 #endif // defined(ASIO_HEADER_ONLY)
 
-#endif // defined(ASIO_WINDOWS) && !defined(UNDER_CE)
+#endif // defined(ASIO_WINDOWS)
+       // && !defined(ASIO_WINDOWS_APP)
+       // && !defined(UNDER_CE)
 
 #endif // ASIO_DETAIL_WIN_THREAD_HPP
diff --git a/extern/include/asio/detail/win_tss_ptr.hpp b/extern/include/asio/detail/win_tss_ptr.hpp
index 64a9ddfc..4207108a 100644
--- a/extern/include/asio/detail/win_tss_ptr.hpp
+++ b/extern/include/asio/detail/win_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/win_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/winapp_thread.hpp b/extern/include/asio/detail/winapp_thread.hpp
new file mode 100644
index 00000000..69dcf08d
--- /dev/null
+++ b/extern/include/asio/detail/winapp_thread.hpp
@@ -0,0 +1,124 @@
+//
+// detail/winapp_thread.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_WINAPP_THREAD_HPP
+#define ASIO_DETAIL_WINAPP_THREAD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS) && defined(ASIO_WINDOWS_APP)
+
+#include "asio/detail/noncopyable.hpp"
+#include "asio/detail/scoped_ptr.hpp"
+#include "asio/detail/socket_types.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+DWORD WINAPI winapp_thread_function(LPVOID arg);
+
+class winapp_thread
+  : private noncopyable
+{
+public:
+  // Constructor.
+  template <typename Function>
+  winapp_thread(Function f, unsigned int = 0)
+  {
+    scoped_ptr<func_base> arg(new func<Function>(f));
+    DWORD thread_id = 0;
+    thread_ = ::CreateThread(0, 0, winapp_thread_function,
+        arg.get(), 0, &thread_id);
+    if (!thread_)
+    {
+      DWORD last_error = ::GetLastError();
+      asio::error_code ec(last_error,
+          asio::error::get_system_category());
+      asio::detail::throw_error(ec, "thread");
+    }
+    arg.release();
+  }
+
+  // Destructor.
+  ~winapp_thread()
+  {
+    ::CloseHandle(thread_);
+  }
+
+  // Wait for the thread to exit.
+  void join()
+  {
+    ::WaitForSingleObjectEx(thread_, INFINITE, false);
+  }
+
+  // Get number of CPUs.
+  static std::size_t hardware_concurrency()
+  {
+    SYSTEM_INFO system_info;
+    ::GetNativeSystemInfo(&system_info);
+    return system_info.dwNumberOfProcessors;
+  }
+
+private:
+  friend DWORD WINAPI winapp_thread_function(LPVOID arg);
+
+  class func_base
+  {
+  public:
+    virtual ~func_base() {}
+    virtual void run() = 0;
+  };
+
+  template <typename Function>
+  class func
+    : public func_base
+  {
+  public:
+    func(Function f)
+      : f_(f)
+    {
+    }
+
+    virtual void run()
+    {
+      f_();
+    }
+
+  private:
+    Function f_;
+  };
+
+  ::HANDLE thread_;
+};
+
+inline DWORD WINAPI winapp_thread_function(LPVOID arg)
+{
+  scoped_ptr<winapp_thread::func_base> func(
+      static_cast<winapp_thread::func_base*>(arg));
+  func->run();
+  return 0;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS) && defined(ASIO_WINDOWS_APP)
+
+#endif // ASIO_DETAIL_WINAPP_THREAD_HPP
diff --git a/extern/include/asio/detail/wince_thread.hpp b/extern/include/asio/detail/wince_thread.hpp
index e15ad3e4..a2863f62 100644
--- a/extern/include/asio/detail/wince_thread.hpp
+++ b/extern/include/asio/detail/wince_thread.hpp
@@ -2,7 +2,7 @@
 // detail/wince_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,8 +19,8 @@
 
 #if defined(ASIO_WINDOWS) && defined(UNDER_CE)
 
-#include <memory>
 #include "asio/detail/noncopyable.hpp"
+#include "asio/detail/scoped_ptr.hpp"
 #include "asio/detail/socket_types.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
@@ -40,7 +40,7 @@ class wince_thread
   template <typename Function>
   wince_thread(Function f, unsigned int = 0)
   {
-    std::auto_ptr<func_base> arg(new func<Function>(f));
+    scoped_ptr<func_base> arg(new func<Function>(f));
     DWORD thread_id = 0;
     thread_ = ::CreateThread(0, 0, wince_thread_function,
         arg.get(), 0, &thread_id);
@@ -66,6 +66,14 @@ class wince_thread
     ::WaitForSingleObject(thread_, INFINITE);
   }
 
+  // Get number of CPUs.
+  static std::size_t hardware_concurrency()
+  {
+    SYSTEM_INFO system_info;
+    ::GetSystemInfo(&system_info);
+    return system_info.dwNumberOfProcessors;
+  }
+
 private:
   friend DWORD WINAPI wince_thread_function(LPVOID arg);
 
@@ -100,7 +108,7 @@ class wince_thread
 
 inline DWORD WINAPI wince_thread_function(LPVOID arg)
 {
-  std::auto_ptr<wince_thread::func_base> func(
+  scoped_ptr<wince_thread::func_base> func(
       static_cast<wince_thread::func_base*>(arg));
   func->run();
   return 0;
diff --git a/extern/include/asio/detail/winrt_async_manager.hpp b/extern/include/asio/detail/winrt_async_manager.hpp
index 9799669e..e22ad52e 100644
--- a/extern/include/asio/detail/winrt_async_manager.hpp
+++ b/extern/include/asio/detail/winrt_async_manager.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_async_manager.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,7 +23,7 @@
 #include "asio/detail/atomic_count.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -35,9 +35,9 @@ class winrt_async_manager
 {
 public:
   // Constructor.
-  winrt_async_manager(asio::io_service& io_service)
-    : asio::detail::service_base<winrt_async_manager>(io_service),
-      io_service_(use_service<io_service_impl>(io_service)),
+  winrt_async_manager(asio::io_context& io_context)
+    : asio::detail::service_base<winrt_async_manager>(io_context),
+      io_context_(use_service<io_context_impl>(io_context)),
       outstanding_ops_(1)
   {
   }
@@ -48,7 +48,7 @@ class winrt_async_manager
   }
 
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
     if (--outstanding_ops_ > 0)
     {
@@ -185,12 +185,12 @@ class winrt_async_manager
               asio::system_category());
           break;
         }
-        io_service_.post_deferred_completion(handler);
+        io_context_.post_deferred_completion(handler);
         if (--outstanding_ops_ == 0)
           promise_.set_value();
       });
 
-    io_service_.work_started();
+    io_context_.work_started();
     ++outstanding_ops_;
     action->Completed = on_completed;
   }
@@ -222,12 +222,12 @@ class winrt_async_manager
               asio::system_category());
           break;
         }
-        io_service_.post_deferred_completion(handler);
+        io_context_.post_deferred_completion(handler);
         if (--outstanding_ops_ == 0)
           promise_.set_value();
       });
 
-    io_service_.work_started();
+    io_context_.work_started();
     ++outstanding_ops_;
     operation->Completed = on_completed;
   }
@@ -263,19 +263,19 @@ class winrt_async_manager
                 asio::system_category());
             break;
           }
-          io_service_.post_deferred_completion(handler);
+          io_context_.post_deferred_completion(handler);
           if (--outstanding_ops_ == 0)
             promise_.set_value();
         });
 
-    io_service_.work_started();
+    io_context_.work_started();
     ++outstanding_ops_;
     operation->Completed = on_completed;
   }
 
 private:
-  // The io_service implementation used to post completed handlers.
-  io_service_impl& io_service_;
+  // The io_context implementation used to post completed handlers.
+  io_context_impl& io_context_;
 
   // Count of outstanding operations.
   atomic_count outstanding_ops_;
diff --git a/extern/include/asio/detail/winrt_async_op.hpp b/extern/include/asio/detail/winrt_async_op.hpp
index 00bc0d12..75891a4a 100644
--- a/extern/include/asio/detail/winrt_async_op.hpp
+++ b/extern/include/asio/detail/winrt_async_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_async_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/winrt_resolve_op.hpp b/extern/include/asio/detail/winrt_resolve_op.hpp
index 35452f4e..07efd29d 100644
--- a/extern/include/asio/detail/winrt_resolve_op.hpp
+++ b/extern/include/asio/detail/winrt_resolve_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_resolve_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,13 +19,13 @@
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
 #include "asio/error.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -44,7 +44,7 @@ class winrt_resolve_op :
 
   typedef typename Protocol::endpoint endpoint_type;
   typedef asio::ip::basic_resolver_query<Protocol> query_type;
-  typedef asio::ip::basic_resolver_iterator<Protocol> iterator_type;
+  typedef asio::ip::basic_resolver_results<Protocol> results_type;
 
   winrt_resolve_op(const query_type& query, Handler& handler)
     : winrt_async_op<
@@ -54,24 +54,25 @@ class winrt_resolve_op :
       query_(query),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code&, std::size_t)
   {
     // Take ownership of the operation object.
     winrt_resolve_op* o(static_cast<winrt_resolve_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
-    iterator_type iterator = iterator_type();
+    results_type results = results_type();
     if (!o->ec_)
     {
       try
       {
-        iterator = iterator_type::create(
-            o->result_, o->query_.hints(),
+        results = results_type::create(o->result_, o->query_.hints(),
             o->query_.host_name(), o->query_.service_name());
       }
       catch (Platform::Exception^ e)
@@ -87,8 +88,8 @@ class winrt_resolve_op :
     // 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, asio::error_code, iterator_type>
-      handler(o->handler_, o->ec_, iterator);
+    detail::binder2<Handler, asio::error_code, results_type>
+      handler(o->handler_, o->ec_, results);
     p.h = asio::detail::addressof(handler.handler_);
     p.reset();
 
@@ -96,8 +97,8 @@ class winrt_resolve_op :
     if (owner)
     {
       fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/winrt_resolver_service.hpp b/extern/include/asio/detail/winrt_resolver_service.hpp
index 12207198..aeb44485 100644
--- a/extern/include/asio/detail/winrt_resolver_service.hpp
+++ b/extern/include/asio/detail/winrt_resolver_service.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,10 +19,10 @@
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 
-#include "asio/ip/basic_resolver_iterator.hpp"
 #include "asio/ip/basic_resolver_query.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
 #include "asio/detail/bind_handler.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/detail/winrt_async_manager.hpp"
 #include "asio/detail/winrt_resolve_op.hpp"
@@ -34,7 +34,8 @@ namespace asio {
 namespace detail {
 
 template <typename Protocol>
-class winrt_resolver_service
+class winrt_resolver_service :
+  public service_base<winrt_resolver_service<Protocol> >
 {
 public:
   // The implementation type of the resolver. A cancellation token is used to
@@ -48,13 +49,14 @@ class winrt_resolver_service
   // The query type.
   typedef asio::ip::basic_resolver_query<Protocol> query_type;
 
-  // The iterator type.
-  typedef asio::ip::basic_resolver_iterator<Protocol> iterator_type;
+  // The results type.
+  typedef asio::ip::basic_resolver_results<Protocol> results_type;
 
   // Constructor.
-  winrt_resolver_service(asio::io_service& io_service)
-    : io_service_(use_service<io_service_impl>(io_service)),
-      async_manager_(use_service<winrt_async_manager>(io_service))
+  winrt_resolver_service(asio::io_context& io_context)
+    : service_base<winrt_resolver_service<Protocol> >(io_context),
+      io_context_(use_service<io_context_impl>(io_context)),
+      async_manager_(use_service<winrt_async_manager>(io_context))
   {
   }
 
@@ -64,12 +66,12 @@ class winrt_resolver_service
   }
 
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
   }
 
   // Perform any fork-related housekeeping.
-  void fork_service(asio::io_service::fork_event)
+  void notify_fork(asio::io_context::fork_event)
   {
   }
 
@@ -78,6 +80,18 @@ class winrt_resolver_service
   {
   }
 
+  // Move-construct a new resolver implementation.
+  void move_construct(implementation_type&,
+      implementation_type&)
+  {
+  }
+
+  // Move-assign from another resolver implementation.
+  void move_assign(implementation_type&,
+      winrt_resolver_service&, implementation_type&)
+  {
+  }
+
   // Destroy a resolver implementation.
   void destroy(implementation_type&)
   {
@@ -89,7 +103,7 @@ class winrt_resolver_service
   }
 
   // Resolve a query to a list of entries.
-  iterator_type resolve(implementation_type&,
+  results_type resolve(implementation_type&,
       const query_type& query, asio::error_code& ec)
   {
     try
@@ -101,9 +115,9 @@ class winrt_resolver_service
             winrt_utils::string(query.service_name())), ec);
 
       if (ec)
-        return iterator_type();
+        return results_type();
 
-      return iterator_type::create(
+      return results_type::create(
           endpoint_pairs, query.hints(),
           query.host_name(), query.service_name());
     }
@@ -111,13 +125,13 @@ class winrt_resolver_service
     {
       ec = asio::error_code(e->HResult,
           asio::system_category());
-      return iterator_type();
+      return results_type();
     }
   }
 
   // Asynchronously resolve a query to a list of entries.
   template <typename Handler>
-  void async_resolve(implementation_type&,
+  void async_resolve(implementation_type& impl,
       const query_type& query, Handler& handler)
   {
     bool is_continuation =
@@ -126,11 +140,12 @@ class winrt_resolver_service
     // Allocate and construct an operation to wrap the handler.
     typedef winrt_resolve_op<Protocol, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(query, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+    ASIO_HANDLER_CREATION((io_context_.context(),
+          *p.p, "resolver", &impl, 0, "async_resolve"));
+    (void)impl;
 
     try
     {
@@ -144,17 +159,17 @@ class winrt_resolver_service
     {
       p.p->ec_ = asio::error_code(
           e->HResult, asio::system_category());
-      io_service_.post_immediate_completion(p.p, is_continuation);
+      io_context_.post_immediate_completion(p.p, is_continuation);
       p.v = p.p = 0;
     }
   }
 
   // Resolve an endpoint to a list of entries.
-  iterator_type resolve(implementation_type&,
+  results_type resolve(implementation_type&,
       const endpoint_type&, asio::error_code& ec)
   {
     ec = asio::error::operation_not_supported;
-    return iterator_type();
+    return results_type();
   }
 
   // Asynchronously resolve an endpoint to a list of entries.
@@ -163,13 +178,13 @@ class winrt_resolver_service
       const endpoint_type&, Handler& handler)
   {
     asio::error_code ec = asio::error::operation_not_supported;
-    const iterator_type iterator;
-    io_service_.get_io_service().post(
-        detail::bind_handler(handler, ec, iterator));
+    const results_type results;
+    io_context_.get_io_context().post(
+        detail::bind_handler(handler, ec, results));
   }
 
 private:
-  io_service_impl& io_service_;
+  io_context_impl& io_context_;
   winrt_async_manager& async_manager_;
 };
 
diff --git a/extern/include/asio/detail/winrt_socket_connect_op.hpp b/extern/include/asio/detail/winrt_socket_connect_op.hpp
index 81f42b03..f18b445f 100644
--- a/extern/include/asio/detail/winrt_socket_connect_op.hpp
+++ b/extern/include/asio/detail/winrt_socket_connect_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_socket_connect_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/error.hpp"
 
@@ -44,16 +44,18 @@ class winrt_socket_connect_op :
     : winrt_async_op<void>(&winrt_socket_connect_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code&, std::size_t)
   {
     // Take ownership of the operation object.
     winrt_socket_connect_op* o(static_cast<winrt_socket_connect_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    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
@@ -70,8 +72,8 @@ class winrt_socket_connect_op :
     if (owner)
     {
       fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/winrt_socket_recv_op.hpp b/extern/include/asio/detail/winrt_socket_recv_op.hpp
index 14744864..8f1fcf57 100644
--- a/extern/include/asio/detail/winrt_socket_recv_op.hpp
+++ b/extern/include/asio/detail/winrt_socket_recv_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/error.hpp"
 
@@ -46,16 +46,18 @@ class winrt_socket_recv_op :
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code&, std::size_t)
   {
     // Take ownership of the operation object.
     winrt_socket_recv_op* o(static_cast<winrt_socket_recv_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
@@ -90,7 +92,7 @@ class winrt_socket_recv_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/winrt_socket_send_op.hpp b/extern/include/asio/detail/winrt_socket_send_op.hpp
index c5345431..1148c24e 100644
--- a/extern/include/asio/detail/winrt_socket_send_op.hpp
+++ b/extern/include/asio/detail/winrt_socket_send_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,12 @@
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/bind_handler.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/error.hpp"
 
@@ -45,16 +45,18 @@ class winrt_socket_send_op :
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler))
   {
+    handler_work<Handler>::start(handler_);
   }
 
-  static void do_complete(io_service_impl* owner, operation* base,
+  static void do_complete(void* owner, operation* base,
       const asio::error_code&, std::size_t)
   {
     // Take ownership of the operation object.
     winrt_socket_send_op* o(static_cast<winrt_socket_send_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
+    handler_work<Handler> w(o->handler_);
 
-    ASIO_HANDLER_COMPLETION((o));
+    ASIO_HANDLER_COMPLETION((*o));
 
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
@@ -81,7 +83,7 @@ class winrt_socket_send_op :
     {
       fenced_block b(fenced_block::half);
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      w.complete(handler, handler.handler_);
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/extern/include/asio/detail/winrt_ssocket_service.hpp b/extern/include/asio/detail/winrt_ssocket_service.hpp
index 0c11913f..603724a3 100644
--- a/extern/include/asio/detail/winrt_ssocket_service.hpp
+++ b/extern/include/asio/detail/winrt_ssocket_service.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_ssocket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,8 +20,8 @@
 #if defined(ASIO_WINDOWS_RUNTIME)
 
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/io_context.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_socket_connect_op.hpp"
 #include "asio/detail/winrt_ssocket_service_base.hpp"
 #include "asio/detail/winrt_utils.hpp"
@@ -33,6 +33,7 @@ namespace detail {
 
 template <typename Protocol>
 class winrt_ssocket_service :
+  public service_base<winrt_ssocket_service<Protocol> >,
   public winrt_ssocket_service_base
 {
 public:
@@ -60,11 +61,18 @@ class winrt_ssocket_service :
   };
 
   // Constructor.
-  winrt_ssocket_service(asio::io_service& io_service)
-    : winrt_ssocket_service_base(io_service)
+  winrt_ssocket_service(asio::io_context& io_context)
+    : service_base<winrt_ssocket_service<Protocol> >(io_context),
+      winrt_ssocket_service_base(io_context)
   {
   }
 
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown()
+  {
+    this->base_shutdown();
+  }
+
   // Move-construct a new socket implementation.
   void move_construct(implementation_type& impl,
       implementation_type& other_impl)
@@ -89,6 +97,7 @@ class winrt_ssocket_service :
   // Move-construct a new socket implementation from another protocol type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      winrt_ssocket_service<Protocol1>&,
       typename winrt_ssocket_service<
         Protocol1>::implementation_type& other_impl)
   {
@@ -211,11 +220,11 @@ class winrt_ssocket_service :
     // Allocate and construct an operation to wrap the handler.
     typedef winrt_socket_connect_op<Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
+    ASIO_HANDLER_CREATION((io_context_.context(),
+          *p.p, "socket", &impl, 0, "async_connect"));
 
     start_connect_op(impl, peer_endpoint.data(), p.p, is_continuation);
     p.v = p.p = 0;
diff --git a/extern/include/asio/detail/winrt_ssocket_service_base.hpp b/extern/include/asio/detail/winrt_ssocket_service_base.hpp
index d290650b..61328d0a 100644
--- a/extern/include/asio/detail/winrt_ssocket_service_base.hpp
+++ b/extern/include/asio/detail/winrt_ssocket_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_ssocket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,10 +21,10 @@
 
 #include "asio/buffer.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/socket_base.hpp"
-#include "asio/detail/addressof.hpp"
 #include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/socket_types.hpp"
 #include "asio/detail/winrt_async_manager.hpp"
 #include "asio/detail/winrt_socket_recv_op.hpp"
@@ -62,10 +62,10 @@ class winrt_ssocket_service_base
 
   // Constructor.
   ASIO_DECL winrt_ssocket_service_base(
-      asio::io_service& io_service);
+      asio::io_context& io_context);
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void base_shutdown();
 
   // Construct a new socket implementation.
   ASIO_DECL void construct(base_implementation_type&);
@@ -92,6 +92,10 @@ class winrt_ssocket_service_base
   ASIO_DECL asio::error_code close(
       base_implementation_type& impl, asio::error_code& ec);
 
+  // Release ownership of the socket.
+  ASIO_DECL native_handle_type release(
+      base_implementation_type& impl, asio::error_code& ec);
+
   // Get the native socket representation.
   native_handle_type native_handle(base_implementation_type& impl)
   {
@@ -199,11 +203,11 @@ class winrt_ssocket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef winrt_socket_send_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
+    ASIO_HANDLER_CREATION((io_context_.context(),
+          *p.p, "socket", &impl, 0, "async_send"));
 
     start_send_op(impl,
         buffer_sequence_adapter<asio::const_buffer,
@@ -219,7 +223,7 @@ class winrt_ssocket_service_base
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.get_io_service().post(
+    io_context_.get_io_context().post(
         detail::bind_handler(handler, ec, bytes_transferred));
   }
 
@@ -255,11 +259,11 @@ class winrt_ssocket_service_base
     // Allocate and construct an operation to wrap the handler.
     typedef winrt_socket_recv_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { asio::detail::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
+      op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
-    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
+    ASIO_HANDLER_CREATION((io_context_.context(),
+          *p.p, "socket", &impl, 0, "async_receive"));
 
     start_receive_op(impl,
         buffer_sequence_adapter<asio::mutable_buffer,
@@ -275,7 +279,7 @@ class winrt_ssocket_service_base
   {
     asio::error_code ec = asio::error::operation_not_supported;
     const std::size_t bytes_transferred = 0;
-    io_service_.get_io_service().post(
+    io_context_.get_io_context().post(
         detail::bind_handler(handler, ec, bytes_transferred));
   }
 
@@ -328,8 +332,8 @@ class winrt_ssocket_service_base
       winrt_async_op<Windows::Storage::Streams::IBuffer^>* op,
       bool is_continuation);
 
-  // The io_service implementation used for delivering completions.
-  io_service_impl& io_service_;
+  // The io_context implementation used for delivering completions.
+  io_context_impl& io_context_;
 
   // The manager that keeps track of outstanding operations.
   winrt_async_manager& async_manager_;
diff --git a/extern/include/asio/detail/winrt_timer_scheduler.hpp b/extern/include/asio/detail/winrt_timer_scheduler.hpp
index 86d87000..5dec7c0b 100644
--- a/extern/include/asio/detail/winrt_timer_scheduler.hpp
+++ b/extern/include/asio/detail/winrt_timer_scheduler.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_timer_scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,7 +28,7 @@
 #include "asio/detail/timer_queue_base.hpp"
 #include "asio/detail/timer_queue_set.hpp"
 #include "asio/detail/wait_op.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #if defined(ASIO_HAS_IOCP)
 # include "asio/detail/thread.hpp"
@@ -44,17 +44,17 @@ class winrt_timer_scheduler
 {
 public:
   // Constructor.
-  ASIO_DECL winrt_timer_scheduler(asio::io_service& io_service);
+  ASIO_DECL winrt_timer_scheduler(asio::io_context& io_context);
 
   // Destructor.
   ASIO_DECL ~winrt_timer_scheduler();
 
   // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
+  ASIO_DECL void shutdown();
 
   // Recreate internal descriptors following a fork.
-  ASIO_DECL void fork_service(
-      asio::io_service::fork_event fork_ev);
+  ASIO_DECL void notify_fork(
+      asio::io_context::fork_event fork_ev);
 
   // Initialise the task. No effect as this class uses its own thread.
   ASIO_DECL void init_task();
@@ -81,6 +81,12 @@ class winrt_timer_scheduler
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Move the timer operations associated with the given timer.
+  template <typename Time_Traits>
+  void move_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& to,
+      typename timer_queue<Time_Traits>::per_timer_data& from);
+
 private:
   // Run the select loop in the thread.
   ASIO_DECL void run_thread();
@@ -94,8 +100,8 @@ class winrt_timer_scheduler
   // Helper function to remove a timer queue.
   ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
+  // The io_context implementation used to post completions.
+  io_context_impl& io_context_;
 
   // Mutex used to protect internal variables.
   asio::detail::mutex mutex_;
diff --git a/extern/include/asio/detail/winrt_utils.hpp b/extern/include/asio/detail/winrt_utils.hpp
index cee6326b..22a24895 100644
--- a/extern/include/asio/detail/winrt_utils.hpp
+++ b/extern/include/asio/detail/winrt_utils.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_utils.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,13 +23,12 @@
 #include <cstdlib>
 #include <future>
 #include <locale>
-#include <memory>
 #include <robuffer.h>
 #include <windows.storage.streams.h>
 #include <wrl/implements.h>
 #include "asio/buffer.hpp"
 #include "asio/error_code.hpp"
-#include "asio/detail/addressof.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/socket_ops.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -83,7 +82,8 @@ inline Windows::Storage::Streams::IBuffer^ buffer_dup(
     const ConstBufferSequence& buffers)
 {
   using Microsoft::WRL::ComPtr;
-  std::size_t size = asio::buffer_size(buffers);
+  using asio::buffer_size;
+  std::size_t size = buffer_size(buffers);
   auto b = ref new Windows::Storage::Streams::Buffer(size);
   ComPtr<IInspectable> insp = reinterpret_cast<IInspectable*>(b);
   ComPtr<Windows::Storage::Streams::IBufferByteAccess> bacc;
diff --git a/extern/include/asio/detail/winsock_init.hpp b/extern/include/asio/detail/winsock_init.hpp
index 425c9d68..9094363a 100644
--- a/extern/include/asio/detail/winsock_init.hpp
+++ b/extern/include/asio/detail/winsock_init.hpp
@@ -2,7 +2,7 @@
 // detail/winsock_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/detail/work_dispatcher.hpp b/extern/include/asio/detail/work_dispatcher.hpp
new file mode 100644
index 00000000..7abce497
--- /dev/null
+++ b/extern/include/asio/detail/work_dispatcher.hpp
@@ -0,0 +1,72 @@
+//
+// detail/work_dispatcher.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_WORK_DISPATCHER_HPP
+#define ASIO_DETAIL_WORK_DISPATCHER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/executor_work_guard.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Handler>
+class work_dispatcher
+{
+public:
+  work_dispatcher(Handler& handler)
+    : work_((get_associated_executor)(handler)),
+      handler_(ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  work_dispatcher(const work_dispatcher& other)
+    : work_(other.work_),
+      handler_(other.handler_)
+  {
+  }
+
+  work_dispatcher(work_dispatcher&& other)
+    : work_(ASIO_MOVE_CAST(executor_work_guard<
+        typename associated_executor<Handler>::type>)(other.work_)),
+      handler_(ASIO_MOVE_CAST(Handler)(other.handler_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    typename associated_allocator<Handler>::type alloc(
+        (get_associated_allocator)(handler_));
+    work_.get_executor().dispatch(
+        ASIO_MOVE_CAST(Handler)(handler_), alloc);
+    work_.reset();
+  }
+
+private:
+  executor_work_guard<typename associated_executor<Handler>::type> work_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_WORK_DISPATCHER_HPP
diff --git a/extern/include/asio/detail/wrapped_handler.hpp b/extern/include/asio/detail/wrapped_handler.hpp
index 1b8edf7d..751f0ea8 100644
--- a/extern/include/asio/detail/wrapped_handler.hpp
+++ b/extern/include/asio/detail/wrapped_handler.hpp
@@ -2,7 +2,7 @@
 // detail/wrapped_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/dispatch.hpp b/extern/include/asio/dispatch.hpp
new file mode 100644
index 00000000..b8dfd691
--- /dev/null
+++ b/extern/include/asio/dispatch.hpp
@@ -0,0 +1,108 @@
+//
+// dispatch.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DISPATCH_HPP
+#define ASIO_DISPATCH_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/async_result.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/is_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// Submits a completion token or function object for execution.
+/**
+ * This function submits an object for execution using the object's associated
+ * executor. The function object is queued for execution, and is never called
+ * from the current thread prior to returning from <tt>dispatch()</tt>.
+ *
+ * This function has the following effects:
+ *
+ * @li Constructs a function object handler of type @c Handler, initialized
+ * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ *
+ * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
+ * initializing the object as <tt>result(handler)</tt>.
+ *
+ * @li Obtains the handler's associated executor object @c ex by performing
+ * <tt>get_associated_executor(handler)</tt>.
+ *
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * <tt>get_associated_allocator(handler)</tt>.
+ *
+ * @li Performs <tt>ex.dispatch(std::move(handler), alloc)</tt>.
+ *
+ * @li Returns <tt>result.get()</tt>.
+ */
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) dispatch(
+    ASIO_MOVE_ARG(CompletionToken) token);
+
+/// Submits a completion token or function object for execution.
+/**
+ * This function submits an object for execution using the specified executor.
+ * The function object is queued for execution, and is never called from the
+ * current thread prior to returning from <tt>dispatch()</tt>.
+ *
+ * This function has the following effects:
+ *
+ * @li Constructs a function object handler of type @c Handler, initialized
+ * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ *
+ * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
+ * initializing the object as <tt>result(handler)</tt>.
+ *
+ * @li Obtains the handler's associated executor object @c ex1 by performing
+ * <tt>get_associated_executor(handler)</tt>.
+ *
+ * @li Creates a work object @c w by performing <tt>make_work(ex1)</tt>.
+ *
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * <tt>get_associated_allocator(handler)</tt>.
+ *
+ * @li Constructs a function object @c f with a function call operator that
+ * performs <tt>ex1.dispatch(std::move(handler), alloc)</tt> followed by
+ * <tt>w.reset()</tt>.
+ *
+ * @li Performs <tt>Executor(ex).dispatch(std::move(f), alloc)</tt>.
+ *
+ * @li Returns <tt>result.get()</tt>.
+ */
+template <typename Executor, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) dispatch(
+    const Executor& ex, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_executor<Executor>::value>::type* = 0);
+
+/// Submits a completion token or function object for execution.
+/**
+ * @returns <tt>dispatch(ctx.get_executor(),
+ * forward<CompletionToken>(token))</tt>.
+ */
+template <typename ExecutionContext, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) dispatch(
+    ExecutionContext& ctx, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type* = 0);
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/dispatch.hpp"
+
+#endif // ASIO_DISPATCH_HPP
diff --git a/extern/include/asio/error.hpp b/extern/include/asio/error.hpp
index bc636310..2be9bdee 100644
--- a/extern/include/asio/error.hpp
+++ b/extern/include/asio/error.hpp
@@ -2,7 +2,7 @@
 // error.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -253,13 +253,17 @@ inline const asio::error_category& get_addrinfo_category()
 extern ASIO_DECL
 const asio::error_category& get_misc_category();
 
-static const asio::error_category& system_category
+static const asio::error_category&
+  system_category ASIO_UNUSED_VARIABLE
   = asio::error::get_system_category();
-static const asio::error_category& netdb_category
+static const asio::error_category&
+  netdb_category ASIO_UNUSED_VARIABLE
   = asio::error::get_netdb_category();
-static const asio::error_category& addrinfo_category
+static const asio::error_category&
+  addrinfo_category ASIO_UNUSED_VARIABLE
   = asio::error::get_addrinfo_category();
-static const asio::error_category& misc_category
+static const asio::error_category&
+  misc_category ASIO_UNUSED_VARIABLE
   = asio::error::get_misc_category();
 
 } // namespace error
@@ -319,6 +323,22 @@ inline asio::error_code make_error_code(misc_errors e)
 }
 
 } // namespace error
+namespace stream_errc {
+  // Simulates the proposed stream_errc scoped enum.
+  using error::eof;
+  using error::not_found;
+} // namespace stream_errc
+namespace socket_errc {
+  // Simulates the proposed socket_errc scoped enum.
+  using error::already_open;
+  using error::not_found;
+} // namespace socket_errc
+namespace resolver_errc {
+  // Simulates the proposed resolver_errc scoped enum.
+  using error::host_not_found;
+  const error::netdb_errors try_again = error::host_not_found_try_again;
+  using error::service_not_found;
+} // namespace resolver_errc
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
diff --git a/extern/include/asio/error_code.hpp b/extern/include/asio/error_code.hpp
index 01248f34..7c239e2f 100644
--- a/extern/include/asio/error_code.hpp
+++ b/extern/include/asio/error_code.hpp
@@ -2,7 +2,7 @@
 // error_code.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -101,6 +101,20 @@ class error_code
     *this = make_error_code(e);
   }
 
+  /// Clear the error value to the default.
+  void clear()
+  {
+    value_ = 0;
+    category_ = &system_category();
+  }
+
+  /// Assign a new error value.
+  void assign(int v, const error_category& c)
+  {
+    value_ = v;
+    category_ = &c;
+  }
+
   /// Get the error value.
   int value() const
   {
diff --git a/extern/include/asio/execution_context.hpp b/extern/include/asio/execution_context.hpp
new file mode 100644
index 00000000..1476d19b
--- /dev/null
+++ b/extern/include/asio/execution_context.hpp
@@ -0,0 +1,411 @@
+//
+// execution_context.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXECUTION_CONTEXT_HPP
+#define ASIO_EXECUTION_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <cstddef>
+#include <stdexcept>
+#include <typeinfo>
+#include "asio/detail/noncopyable.hpp"
+#include "asio/detail/variadic_templates.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+class execution_context;
+class io_context;
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Service> Service& use_service(execution_context&);
+template <typename Service> Service& use_service(io_context&);
+template <typename Service> void add_service(execution_context&, Service*);
+template <typename Service> bool has_service(execution_context&);
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+namespace detail { class service_registry; }
+
+/// A context for function object execution.
+/**
+ * An execution context represents a place where function objects will be
+ * executed. An @c io_context is an example of an execution context.
+ *
+ * @par The execution_context class and services
+ *
+ * Class execution_context implements an extensible, type-safe, polymorphic set
+ * of services, indexed by service type.
+ *
+ * Services exist to manage the resources that are shared across an execution
+ * context. For example, timers may be implemented in terms of a single timer
+ * queue, and this queue would be stored in a service.
+ *
+ * Access to the services of an execution_context is via three function
+ * templates, use_service(), add_service() and has_service().
+ *
+ * In a call to @c use_service<Service>(), the type argument chooses a service,
+ * making available all members of the named type. If @c Service is not present
+ * in an execution_context, an object of type @c Service is created and added
+ * to the execution_context. A C++ program can check if an execution_context
+ * implements a particular service with the function template @c
+ * has_service<Service>().
+ *
+ * Service objects may be explicitly added to an execution_context using the
+ * function template @c add_service<Service>(). If the @c Service is already
+ * present, the service_already_exists exception is thrown. If the owner of the
+ * service is not the same object as the execution_context parameter, the
+ * invalid_service_owner exception is thrown.
+ *
+ * Once a service reference is obtained from an execution_context object by
+ * calling use_service(), that reference remains usable as long as the owning
+ * execution_context object exists.
+ *
+ * All service implementations have execution_context::service as a public base
+ * class. Custom services may be implemented by deriving from this class and
+ * then added to an execution_context using the facilities described above.
+ *
+ * @par The execution_context as a base class
+ *
+ * Class execution_context may be used only as a base class for concrete
+ * execution context types. The @c io_context is an example of such a derived
+ * type.
+ *
+ * On destruction, a class that is derived from execution_context must perform
+ * <tt>execution_context::shutdown()</tt> followed by
+ * <tt>execution_context::destroy()</tt>.
+ *
+ * This destruction sequence permits programs to simplify their resource
+ * management by using @c shared_ptr<>. Where an object's lifetime is tied to
+ * the lifetime of a connection (or some other sequence of asynchronous
+ * operations), a @c shared_ptr to the object would be bound into the handlers
+ * for all asynchronous operations associated with it. This works as follows:
+ *
+ * @li When a single connection ends, all associated asynchronous operations
+ * complete. The corresponding handler objects are destroyed, and all @c
+ * shared_ptr references to the objects are destroyed.
+ *
+ * @li To shut down the whole program, the io_context function stop() is called
+ * to terminate any run() calls as soon as possible. The io_context destructor
+ * calls @c shutdown() and @c destroy() to destroy all pending handlers,
+ * causing all @c shared_ptr references to all connection objects to be
+ * destroyed.
+ */
+class execution_context
+  : private noncopyable
+{
+public:
+  class id;
+  class service;
+
+protected:
+  /// Constructor.
+  ASIO_DECL execution_context();
+
+  /// Destructor.
+  ASIO_DECL ~execution_context();
+
+  /// Shuts down all services in the context.
+  /**
+   * This function is implemented as follows:
+   *
+   * @li For each service object @c svc in the execution_context set, in
+   * reverse order of the beginning of service object lifetime, performs @c
+   * svc->shutdown().
+   */
+  ASIO_DECL void shutdown();
+
+  /// Destroys all services in the context.
+  /**
+   * This function is implemented as follows:
+   *
+   * @li For each service object @c svc in the execution_context set, in
+   * reverse order * of the beginning of service object lifetime, performs
+   * <tt>delete static_cast<execution_context::service*>(svc)</tt>.
+   */
+  ASIO_DECL void destroy();
+
+public:
+  /// Fork-related event notifications.
+  enum fork_event
+  {
+    /// Notify the context that the process is about to fork.
+    fork_prepare,
+
+    /// Notify the context that the process has forked and is the parent.
+    fork_parent,
+
+    /// Notify the context that the process has forked and is the child.
+    fork_child
+  };
+
+  /// Notify the execution_context of a fork-related event.
+  /**
+   * This function is used to inform the execution_context that the process is
+   * about to fork, or has just forked. This allows the execution_context, 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 execution_context
+   * function, or any function associated with the execution_context's derived
+   * class, 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 execution_context or its derived class.
+   *
+   * @param event A fork-related event.
+   *
+   * @throws asio::system_error Thrown on failure. If the notification
+   * fails the execution_context 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_execution_context.notify_fork(execution_context::fork_prepare);
+   * if (fork() == 0)
+   * {
+   *   // This is the child process.
+   *   my_execution_context.notify_fork(execution_context::fork_child);
+   * }
+   * else
+   * {
+   *   // This is the parent process.
+   *   my_execution_context.notify_fork(execution_context::fork_parent);
+   * } @endcode
+   *
+   * @note For each service object @c svc in the execution_context set,
+   * performs <tt>svc->notify_fork();</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.
+   */
+  ASIO_DECL void notify_fork(fork_event event);
+
+  /// Obtain the service object corresponding to the given type.
+  /**
+   * This function is used to locate a service object that corresponds to the
+   * given service type. If there is no existing implementation of the service,
+   * then the execution_context will create a new instance of the service.
+   *
+   * @param e The execution_context object that owns the service.
+   *
+   * @return The service interface implementing the specified service type.
+   * Ownership of the service interface is not transferred to the caller.
+   */
+  template <typename Service>
+  friend Service& use_service(execution_context& e);
+
+  /// Obtain the service object corresponding to the given type.
+  /**
+   * This function is used to locate a service object that corresponds to the
+   * given service type. If there is no existing implementation of the service,
+   * then the io_context will create a new instance of the service.
+   *
+   * @param ioc The io_context object that owns the service.
+   *
+   * @return The service interface implementing the specified service type.
+   * Ownership of the service interface is not transferred to the caller.
+   *
+   * @note This overload is preserved for backwards compatibility with services
+   * that inherit from io_context::service.
+   */
+  template <typename Service>
+  friend Service& use_service(io_context& ioc);
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  /// Creates a service object and adds it to the execution_context.
+  /**
+   * This function is used to add a service to the execution_context.
+   *
+   * @param e The execution_context object that owns the service.
+   *
+   * @param args Zero or more arguments to be passed to the service
+   * constructor.
+   *
+   * @throws asio::service_already_exists Thrown if a service of the
+   * given type is already present in the execution_context.
+   */
+  template <typename Service, typename... Args>
+  friend Service& make_service(execution_context& e, Args&&... args);
+
+#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Service, typename... Args>
+  friend Service& make_service(execution_context& e,
+      ASIO_MOVE_ARG(Args)... args);
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Service>
+  friend Service& make_service(execution_context& e);
+
+#define ASIO_PRIVATE_MAKE_SERVICE_DEF(n) \
+  template <typename Service, ASIO_VARIADIC_TPARAMS(n)> \
+  friend Service& make_service(execution_context& e, \
+      ASIO_VARIADIC_MOVE_PARAMS(n)); \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_MAKE_SERVICE_DEF)
+#undef ASIO_PRIVATE_MAKE_SERVICE_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// (Deprecated: Use make_service().) Add a service object to the
+  /// execution_context.
+  /**
+   * This function is used to add a service to the execution_context.
+   *
+   * @param e The execution_context object that owns the service.
+   *
+   * @param svc The service object. On success, ownership of the service object
+   * is transferred to the execution_context. When the execution_context object
+   * is destroyed, it will destroy the service object by performing: @code
+   * delete static_cast<execution_context::service*>(svc) @endcode
+   *
+   * @throws asio::service_already_exists Thrown if a service of the
+   * given type is already present in the execution_context.
+   *
+   * @throws asio::invalid_service_owner Thrown if the service's owning
+   * execution_context is not the execution_context object specified by the
+   * @c e parameter.
+   */
+  template <typename Service>
+  friend void add_service(execution_context& e, Service* svc);
+
+  /// Determine if an execution_context contains a specified service type.
+  /**
+   * This function is used to determine whether the execution_context contains a
+   * service object corresponding to the given service type.
+   *
+   * @param e The execution_context object that owns the service.
+   *
+   * @return A boolean indicating whether the execution_context contains the
+   * service.
+   */
+  template <typename Service>
+  friend bool has_service(execution_context& e);
+
+private:
+  // The service registry.
+  asio::detail::service_registry* service_registry_;
+};
+
+/// Class used to uniquely identify a service.
+class execution_context::id
+  : private noncopyable
+{
+public:
+  /// Constructor.
+  id() {}
+};
+
+/// Base class for all io_context services.
+class execution_context::service
+  : private noncopyable
+{
+public:
+  /// Get the context object that owns the service.
+  execution_context& context();
+
+protected:
+  /// Constructor.
+  /**
+   * @param owner The execution_context object that owns the service.
+   */
+  ASIO_DECL service(execution_context& owner);
+
+  /// Destructor.
+  ASIO_DECL virtual ~service();
+
+private:
+  /// Destroy all user-defined handler objects owned by the service.
+  virtual void shutdown() = 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.
+   */
+  ASIO_DECL virtual void notify_fork(
+      execution_context::fork_event event);
+
+  friend class asio::detail::service_registry;
+  struct key
+  {
+    key() : type_info_(0), id_(0) {}
+    const std::type_info* type_info_;
+    const execution_context::id* id_;
+  } key_;
+
+  execution_context& owner_;
+  service* next_;
+};
+
+/// Exception thrown when trying to add a duplicate service to an
+/// execution_context.
+class service_already_exists
+  : public std::logic_error
+{
+public:
+  ASIO_DECL service_already_exists();
+};
+
+/// Exception thrown when trying to add a service object to an
+/// execution_context where the service has a different owner.
+class invalid_service_owner
+  : public std::logic_error
+{
+public:
+  ASIO_DECL invalid_service_owner();
+};
+
+namespace detail {
+
+// Special derived service id type to keep classes header-file only.
+template <typename Type>
+class service_id
+  : public execution_context::id
+{
+};
+
+// Special service base class to keep classes header-file only.
+template <typename Type>
+class execution_context_service_base
+  : public execution_context::service
+{
+public:
+  static service_id<Type> id;
+
+  // Constructor.
+  execution_context_service_base(execution_context& e)
+    : execution_context::service(e)
+  {
+  }
+};
+
+template <typename Type>
+service_id<Type> execution_context_service_base<Type>::id;
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/execution_context.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/execution_context.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_EXECUTION_CONTEXT_HPP
diff --git a/extern/include/asio/executor.hpp b/extern/include/asio/executor.hpp
new file mode 100644
index 00000000..e552cfbf
--- /dev/null
+++ b/extern/include/asio/executor.hpp
@@ -0,0 +1,341 @@
+//
+// executor.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXECUTOR_HPP
+#define ASIO_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <typeinfo>
+#include "asio/detail/cstddef.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/execution_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// Exception thrown when trying to access an empty polymorphic executor.
+class bad_executor
+  : public std::exception
+{
+public:
+  /// Constructor.
+  ASIO_DECL bad_executor() ASIO_NOEXCEPT;
+
+  /// Obtain message associated with exception.
+  ASIO_DECL virtual const char* what() const
+    ASIO_NOEXCEPT_OR_NOTHROW;
+};
+
+/// Polymorphic wrapper for executors.
+class executor
+{
+public:
+  /// Default constructor.
+  executor() ASIO_NOEXCEPT
+    : impl_(0)
+  {
+  }
+
+  /// Construct from nullptr.
+  executor(nullptr_t) ASIO_NOEXCEPT
+    : impl_(0)
+  {
+  }
+
+  /// Copy constructor.
+  executor(const executor& other) ASIO_NOEXCEPT
+    : impl_(other.clone())
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  executor(executor&& other) ASIO_NOEXCEPT
+    : impl_(other.impl_)
+  {
+    other.impl_ = 0;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a polymorphic wrapper for the specified executor.
+  template <typename Executor>
+  executor(Executor e);
+
+  /// Allocator-aware constructor to create a polymorphic wrapper for the
+  /// specified executor.
+  template <typename Executor, typename Allocator>
+  executor(allocator_arg_t, const Allocator& a, Executor e);
+
+  /// Destructor.
+  ~executor()
+  {
+    destroy();
+  }
+
+  /// Assignment operator.
+  executor& operator=(const executor& other) ASIO_NOEXCEPT
+  {
+    destroy();
+    impl_ = other.clone();
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  // Move assignment operator.
+  executor& operator=(executor&& other) ASIO_NOEXCEPT
+  {
+    destroy();
+    impl_ = other.impl_;
+    other.impl_ = 0;
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Assignment operator for nullptr_t.
+  executor& operator=(nullptr_t) ASIO_NOEXCEPT
+  {
+    destroy();
+    impl_ = 0;
+    return *this;
+  }
+
+  /// Assignment operator to create a polymorphic wrapper for the specified
+  /// executor.
+  template <typename Executor>
+  executor& operator=(ASIO_MOVE_ARG(Executor) e) ASIO_NOEXCEPT
+  {
+    executor tmp(ASIO_MOVE_CAST(Executor)(e));
+    destroy();
+    impl_ = tmp.impl_;
+    tmp.impl_ = 0;
+    return *this;
+  }
+
+  /// Obtain the underlying execution context.
+  execution_context& context() const ASIO_NOEXCEPT
+  {
+    return get_impl()->context();
+  }
+
+  /// Inform the executor that it has some outstanding work to do.
+  void on_work_started() const ASIO_NOEXCEPT
+  {
+    get_impl()->on_work_started();
+  }
+
+  /// Inform the executor that some work is no longer outstanding.
+  void on_work_finished() const ASIO_NOEXCEPT
+  {
+    get_impl()->on_work_finished();
+  }
+
+  /// Request the executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object is executed according to the rules of the
+   * target executor object.
+   *
+   * @param f The function object to be called. The executor will make a copy
+   * of the handler object as required. The function signature of the function
+   * object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object is executed according to the rules of the
+   * target executor object.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void post(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object is executed according to the rules of the
+   * target executor object.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void defer(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  struct unspecified_bool_type_t {};
+  typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
+  static void unspecified_bool_true(unspecified_bool_type_t) {}
+
+  /// Operator to test if the executor contains a valid target.
+  operator unspecified_bool_type() const ASIO_NOEXCEPT
+  {
+    return impl_ ? &executor::unspecified_bool_true : 0;
+  }
+
+  /// Obtain type information for the target executor object.
+  /**
+   * @returns If @c *this has a target type of type @c T, <tt>typeid(T)</tt>;
+   * otherwise, <tt>typeid(void)</tt>.
+   */
+#if !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
+  const std::type_info& target_type() const ASIO_NOEXCEPT
+  {
+    return impl_ ? impl_->target_type() : typeid(void);
+  }
+#else // !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
+  const void* target_type() const ASIO_NOEXCEPT
+  {
+    return impl_ ? impl_->target_type() : 0;
+  }
+#endif // !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
+
+  /// Obtain a pointer to the target executor object.
+  /**
+   * @returns If <tt>target_type() == typeid(T)</tt>, a pointer to the stored
+   * executor target; otherwise, a null pointer.
+   */
+  template <typename Executor>
+  Executor* target() ASIO_NOEXCEPT;
+
+  /// Obtain a pointer to the target executor object.
+  /**
+   * @returns If <tt>target_type() == typeid(T)</tt>, a pointer to the stored
+   * executor target; otherwise, a null pointer.
+   */
+  template <typename Executor>
+  const Executor* target() const ASIO_NOEXCEPT;
+
+  /// Compare two executors for equality.
+  friend bool operator==(const executor& a,
+      const executor& b) ASIO_NOEXCEPT
+  {
+    if (a.impl_ == b.impl_)
+      return true;
+    if (!a.impl_ || !b.impl_)
+      return false;
+    return a.impl_->equals(b.impl_);
+  }
+
+  /// Compare two executors for inequality.
+  friend bool operator!=(const executor& a,
+      const executor& b) ASIO_NOEXCEPT
+  {
+    return !(a == b);
+  }
+
+private:
+#if !defined(GENERATING_DOCUMENTATION)
+  class function;
+  template <typename, typename> class impl;
+
+#if !defined(ASIO_NO_TYPEID)
+  typedef const std::type_info& type_id_result_type;
+#else // !defined(ASIO_NO_TYPEID)
+  typedef const void* type_id_result_type;
+#endif // !defined(ASIO_NO_TYPEID)
+
+  template <typename T>
+  static type_id_result_type type_id()
+  {
+#if !defined(ASIO_NO_TYPEID)
+    return typeid(T);
+#else // !defined(ASIO_NO_TYPEID)
+    static int unique_id;
+    return &unique_id;
+#endif // !defined(ASIO_NO_TYPEID)
+  }
+
+  // Base class for all polymorphic executor implementations.
+  class impl_base
+  {
+  public:
+    virtual impl_base* clone() const ASIO_NOEXCEPT = 0;
+    virtual void destroy() ASIO_NOEXCEPT = 0;
+    virtual execution_context& context() ASIO_NOEXCEPT = 0;
+    virtual void on_work_started() ASIO_NOEXCEPT = 0;
+    virtual void on_work_finished() ASIO_NOEXCEPT = 0;
+    virtual void dispatch(ASIO_MOVE_ARG(function)) = 0;
+    virtual void post(ASIO_MOVE_ARG(function)) = 0;
+    virtual void defer(ASIO_MOVE_ARG(function)) = 0;
+    virtual type_id_result_type target_type() const ASIO_NOEXCEPT = 0;
+    virtual void* target() ASIO_NOEXCEPT = 0;
+    virtual const void* target() const ASIO_NOEXCEPT = 0;
+    virtual bool equals(const impl_base* e) const ASIO_NOEXCEPT = 0;
+
+  protected:
+    impl_base(bool fast_dispatch) : fast_dispatch_(fast_dispatch) {}
+    virtual ~impl_base() {}
+
+  private:
+    friend class executor;
+    const bool fast_dispatch_;
+  };
+
+  // Helper function to check and return the implementation pointer.
+  impl_base* get_impl() const
+  {
+    if (!impl_)
+    {
+      bad_executor ex;
+      asio::detail::throw_exception(ex);
+    }
+    return impl_;
+  }
+
+  // Helper function to clone another implementation.
+  impl_base* clone() const ASIO_NOEXCEPT
+  {
+    return impl_ ? impl_->clone() : 0;
+  }
+
+  // Helper function to destroy an implementation.
+  void destroy() ASIO_NOEXCEPT
+  {
+    if (impl_)
+      impl_->destroy();
+  }
+
+  impl_base* impl_;
+#endif // !defined(GENERATING_DOCUMENTATION)
+};
+
+} // namespace asio
+
+ASIO_USES_ALLOCATOR(asio::executor)
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/executor.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/executor.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_EXECUTOR_HPP
diff --git a/extern/include/asio/executor_work_guard.hpp b/extern/include/asio/executor_work_guard.hpp
new file mode 100644
index 00000000..1875f542
--- /dev/null
+++ b/extern/include/asio/executor_work_guard.hpp
@@ -0,0 +1,170 @@
+//
+// executor_work_guard.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXECUTOR_WORK_GUARD_HPP
+#define ASIO_EXECUTOR_WORK_GUARD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/is_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// An object of type @c executor_work_guard controls ownership of executor work
+/// within a scope.
+template <typename Executor>
+class executor_work_guard
+{
+public:
+  /// The underlying executor type.
+  typedef Executor executor_type;
+
+  /// Constructs a @c executor_work_guard object for the specified executor.
+  /**
+   * Stores a copy of @c e and calls <tt>on_work_started()</tt> on it.
+   */
+  explicit executor_work_guard(const executor_type& e) ASIO_NOEXCEPT
+    : executor_(e),
+      owns_(true)
+  {
+    executor_.on_work_started();
+  }
+
+  /// Copy constructor.
+  executor_work_guard(const executor_work_guard& other) ASIO_NOEXCEPT
+    : executor_(other.executor_),
+      owns_(other.owns_)
+  {
+    if (owns_)
+      executor_.on_work_started();
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  executor_work_guard(executor_work_guard&& other)
+    : executor_(ASIO_MOVE_CAST(Executor)(other.executor_)),
+      owns_(other.owns_)
+  {
+    other.owns_ = false;
+  }
+#endif //  defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  /**
+   * Unless the object has already been reset, or is in a moved-from state,
+   * calls <tt>on_work_finished()</tt> on the stored executor.
+   */
+  ~executor_work_guard()
+  {
+    if (owns_)
+      executor_.on_work_finished();
+  }
+
+  /// Obtain the associated executor.
+  executor_type get_executor() const ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+  /// Whether the executor_work_guard object owns some outstanding work.
+  bool owns_work() const ASIO_NOEXCEPT
+  {
+    return owns_;
+  }
+
+  /// Indicate that the work is no longer outstanding.
+  /*
+   * Unless the object has already been reset, or is in a moved-from state,
+   * calls <tt>on_work_finished()</tt> on the stored executor.
+   */
+  void reset() ASIO_NOEXCEPT
+  {
+    if (owns_)
+    {
+      executor_.on_work_finished();
+      owns_ = false;
+    }
+  }
+
+private:
+  // Disallow assignment.
+  executor_work_guard& operator=(const executor_work_guard&);
+
+  executor_type executor_;
+  bool owns_;
+};
+
+/// Create an @ref executor_work_guard object.
+template <typename Executor>
+inline executor_work_guard<Executor> make_work_guard(const Executor& ex,
+    typename enable_if<is_executor<Executor>::value>::type* = 0)
+{
+  return executor_work_guard<Executor>(ex);
+}
+
+/// Create an @ref executor_work_guard object.
+template <typename ExecutionContext>
+inline executor_work_guard<typename ExecutionContext::executor_type>
+make_work_guard(ExecutionContext& ctx,
+    typename enable_if<
+      is_convertible<ExecutionContext&, execution_context&>::value>::type* = 0)
+{
+  return executor_work_guard<typename ExecutionContext::executor_type>(
+      ctx.get_executor());
+}
+
+/// Create an @ref executor_work_guard object.
+template <typename T>
+inline executor_work_guard<typename associated_executor<T>::type>
+make_work_guard(const T& t,
+    typename enable_if<!is_executor<T>::value &&
+      !is_convertible<T&, execution_context&>::value>::type* = 0)
+{
+  return executor_work_guard<typename associated_executor<T>::type>(
+      associated_executor<T>::get(t));
+}
+
+/// Create an @ref executor_work_guard object.
+template <typename T, typename Executor>
+inline executor_work_guard<typename associated_executor<T, Executor>::type>
+make_work_guard(const T& t, const Executor& ex,
+    typename enable_if<is_executor<Executor>::value>::type* = 0)
+{
+  return executor_work_guard<typename associated_executor<T, Executor>::type>(
+      associated_executor<T, Executor>::get(t, ex));
+}
+
+/// Create an @ref executor_work_guard object.
+template <typename T, typename ExecutionContext>
+inline executor_work_guard<typename associated_executor<T,
+  typename ExecutionContext::executor_type>::type>
+make_work_guard(const T& t, ExecutionContext& ctx,
+    typename enable_if<!is_executor<T>::value &&
+      !is_convertible<T&, execution_context&>::value &&
+      is_convertible<ExecutionContext&, execution_context&>::value>::type* = 0)
+{
+  return executor_work_guard<typename associated_executor<T,
+    typename ExecutionContext::executor_type>::type>(
+      associated_executor<T, typename ExecutionContext::executor_type>::get(
+        t, ctx.get_executor()));
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTOR_WORK_GUARD_HPP
diff --git a/extern/include/asio/experimental.hpp b/extern/include/asio/experimental.hpp
new file mode 100644
index 00000000..5765c37d
--- /dev/null
+++ b/extern/include/asio/experimental.hpp
@@ -0,0 +1,22 @@
+//
+// experimental.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXPERIMENTAL_HPP
+#define ASIO_EXPERIMENTAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/experimental/co_spawn.hpp"
+#include "asio/experimental/detached.hpp"
+#include "asio/experimental/redirect_error.hpp"
+
+#endif // ASIO_EXPERIMENTAL_HPP
diff --git a/extern/include/asio/experimental/co_spawn.hpp b/extern/include/asio/experimental/co_spawn.hpp
new file mode 100644
index 00000000..cbf5bc52
--- /dev/null
+++ b/extern/include/asio/experimental/co_spawn.hpp
@@ -0,0 +1,226 @@
+//
+// experimental/co_spawn.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXPERIMENTAL_CO_SPAWN_HPP
+#define ASIO_EXPERIMENTAL_CO_SPAWN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
+
+#include <experimental/coroutine>
+#include "asio/executor.hpp"
+#include "asio/strand.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace experimental {
+namespace detail {
+
+using std::experimental::coroutine_handle;
+
+template <typename> class awaiter;
+template <typename> class awaitee_base;
+template <typename, typename> class awaitee;
+template <typename, typename> class await_handler_base;
+template <typename Executor, typename F, typename CompletionToken>
+auto co_spawn(const Executor& ex, F&& f, CompletionToken&& token);
+
+} // namespace detail
+
+namespace this_coro {
+
+/// Awaitable type that returns a completion token for the current coroutine.
+struct token_t {};
+
+/// Awaitable object that returns a completion token for the current coroutine.
+constexpr inline token_t token() { return {}; }
+
+/// Awaitable type that returns the executor of the current coroutine.
+struct executor_t {};
+
+/// Awaitable object that returns the executor of the current coroutine.
+constexpr inline executor_t executor() { return {}; }
+
+} // namespace this_coro
+
+/// A completion token that represents the currently executing coroutine.
+/**
+ * The await_token class is used to represent the currently executing
+ * coroutine. An await_token may be passed as a handler to an asynchronous
+ * operation. For example:
+ *
+ * @code awaitable<void> my_coroutine()
+ * {
+ *   await_token token = co_await this_coro::token();
+ *   ...
+ *   std::size_t n = co_await my_socket.async_read_some(buffer, token);
+ *   ...
+ * } @endcode
+ *
+ * The initiating function (async_read_some in the above example) suspends the
+ * current coroutine. The coroutine is resumed when the asynchronous operation
+ * completes, and the result of the operation is returned.
+ */
+template <typename Executor>
+class await_token
+{
+public:
+  /// The associated executor type.
+  typedef Executor executor_type;
+
+  /// Copy constructor.
+  await_token(const await_token& other) noexcept
+    : awaiter_(other.awaiter_)
+  {
+  }
+
+  /// Move constructor.
+  await_token(await_token&& other) noexcept
+    : awaiter_(std::exchange(other.awaiter_, nullptr))
+  {
+  }
+
+  /// Get the associated executor.
+  executor_type get_executor() const noexcept
+  {
+    return awaiter_->get_executor();
+  }
+
+private:
+  // No assignment allowed.
+  await_token& operator=(const await_token&) = delete;
+
+  template <typename> friend class detail::awaitee_base;
+  template <typename, typename> friend class detail::await_handler_base;
+
+  // Private constructor used by awaitee_base.
+  explicit await_token(detail::awaiter<Executor>* a)
+    : awaiter_(a)
+  {
+  }
+
+  detail::awaiter<Executor>* awaiter_;
+};
+
+/// The return type of a coroutine or asynchronous operation.
+template <typename T, typename Executor = strand<executor>>
+class awaitable
+{
+public:
+  /// The type of the awaited value.
+  typedef T value_type;
+
+  /// The executor type that will be used for the coroutine.
+  typedef Executor executor_type;
+
+  /// Move constructor.
+  awaitable(awaitable&& other) noexcept
+    : awaitee_(std::exchange(other.awaitee_, nullptr))
+  {
+  }
+
+  /// Destructor
+  ~awaitable()
+  {
+    if (awaitee_)
+    {
+      detail::coroutine_handle<
+        detail::awaitee<T, Executor>>::from_promise(
+          *awaitee_).destroy();
+    }
+  }
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+  // Support for co_await keyword.
+  bool await_ready() const noexcept
+  {
+    return awaitee_->ready();
+  }
+
+  // Support for co_await keyword.
+  void await_suspend(detail::coroutine_handle<detail::awaiter<Executor>> h)
+  {
+    awaitee_->attach_caller(h);
+  }
+
+  // Support for co_await keyword.
+  template <class U>
+  void await_suspend(detail::coroutine_handle<detail::awaitee<U, Executor>> h)
+  {
+    awaitee_->attach_caller(h);
+  }
+
+  // Support for co_await keyword.
+  T await_resume()
+  {
+    return awaitee_->get();
+  }
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+private:
+  template <typename, typename> friend class detail::awaitee;
+  template <typename, typename> friend class detail::await_handler_base;
+
+  // Not copy constructible or copy assignable.
+  awaitable(const awaitable&) = delete;
+  awaitable& operator=(const awaitable&) = delete;
+
+  // Construct the awaitable from a coroutine's promise object.
+  explicit awaitable(detail::awaitee<T, Executor>* a) : awaitee_(a) {}
+
+  detail::awaitee<T, Executor>* awaitee_;
+};
+
+/// Spawn a new thread of execution.
+template <typename Executor, typename F, typename CompletionToken,
+    typename = typename enable_if<is_executor<Executor>::value>::type>
+inline auto co_spawn(const Executor& ex, F&& f, CompletionToken&& token)
+{
+  return detail::co_spawn(ex, std::forward<F>(f),
+      std::forward<CompletionToken>(token));
+}
+
+/// Spawn a new thread of execution.
+template <typename ExecutionContext, typename F, typename CompletionToken,
+    typename = typename enable_if<
+      is_convertible<ExecutionContext&, execution_context&>::value>::type>
+inline auto co_spawn(ExecutionContext& ctx, F&& f, CompletionToken&& token)
+{
+  return detail::co_spawn(ctx.get_executor(), std::forward<F>(f),
+      std::forward<CompletionToken>(token));
+}
+
+/// Spawn a new thread of execution.
+template <typename Executor, typename F, typename CompletionToken>
+inline auto co_spawn(const await_token<Executor>& parent,
+    F&& f, CompletionToken&& token)
+{
+  return detail::co_spawn(parent.get_executor(), std::forward<F>(f),
+      std::forward<CompletionToken>(token));
+}
+
+} // namespace experimental
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/experimental/impl/co_spawn.hpp"
+
+#endif // defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
+
+#endif // ASIO_EXPERIMENTAL_CO_SPAWN_HPP
diff --git a/extern/include/asio/experimental/detached.hpp b/extern/include/asio/experimental/detached.hpp
new file mode 100644
index 00000000..d484f18f
--- /dev/null
+++ b/extern/include/asio/experimental/detached.hpp
@@ -0,0 +1,65 @@
+//
+// experimental/detached.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXPERIMENTAL_DETACHED_HPP
+#define ASIO_EXPERIMENTAL_DETACHED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <memory>
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace experimental {
+
+/// Class used to specify that an asynchronous operation is detached.
+/**
+
+ * The detached_t class is used to indicate that an asynchronous operation is
+ * detached. That is, there is no completion handler waiting for the
+ * operation's result. A detached_t object may be passed as a handler to an
+ * asynchronous operation, typically using the special value
+ * @c asio::experimental::detached. For example:
+
+ * @code my_socket.async_send(my_buffer, asio::experimental::detached);
+ * @endcode
+ */
+class detached_t
+{
+public:
+  /// Constructor. 
+  ASIO_CONSTEXPR detached_t()
+  {
+  }
+};
+
+/// A special value, similar to std::nothrow.
+/**
+ * See the documentation for asio::experimental::detached_t for a usage
+ * example.
+ */
+#if defined(ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
+constexpr detached_t detached;
+#elif defined(ASIO_MSVC)
+__declspec(selectany) detached_t detached;
+#endif
+
+} // namespace experimental
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/experimental/impl/detached.hpp"
+
+#endif // ASIO_EXPERIMENTAL_DETACHED_HPP
diff --git a/extern/include/asio/experimental/impl/co_spawn.hpp b/extern/include/asio/experimental/impl/co_spawn.hpp
new file mode 100644
index 00000000..8263eff9
--- /dev/null
+++ b/extern/include/asio/experimental/impl/co_spawn.hpp
@@ -0,0 +1,876 @@
+//
+// experimental/impl/co_spawn.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXPERIMENTAL_IMPL_CO_SPAWN_HPP
+#define ASIO_EXPERIMENTAL_IMPL_CO_SPAWN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <exception>
+#include <functional>
+#include <memory>
+#include <new>
+#include <tuple>
+#include <utility>
+#include "asio/async_result.hpp"
+#include "asio/detail/thread_context.hpp"
+#include "asio/detail/thread_info_base.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/dispatch.hpp"
+#include "asio/post.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Promise object for coroutine at top of thread-of-execution "stack".
+template <typename Executor>
+class awaiter
+{
+public:
+  struct deleter
+  {
+    void operator()(awaiter* a)
+    {
+      if (a)
+        a->release();
+    }
+  };
+
+  typedef std::unique_ptr<awaiter, deleter> ptr;
+
+  typedef Executor executor_type;
+
+  ~awaiter()
+  {
+    if (has_executor_)
+      static_cast<Executor*>(static_cast<void*>(executor_))->~Executor();
+  }
+
+  void set_executor(const Executor& ex)
+  {
+    new (&executor_) Executor(ex);
+    has_executor_ = true;
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return *static_cast<const Executor*>(static_cast<const void*>(executor_));
+  }
+
+  awaiter* get_return_object()
+  {
+    return this;
+  }
+
+  auto initial_suspend()
+  {
+    return std::experimental::suspend_always();
+  }
+
+  auto final_suspend()
+  {
+    return std::experimental::suspend_always();
+  }
+
+  void return_void()
+  {
+  }
+
+  awaiter* add_ref()
+  {
+    ++ref_count_;
+    return this;
+  }
+
+  void release()
+  {
+    if (--ref_count_ == 0)
+      coroutine_handle<awaiter>::from_promise(*this).destroy();
+  }
+
+  void unhandled_exception()
+  {
+    pending_exception_ = std::current_exception();
+  }
+
+  void rethrow_unhandled_exception()
+  {
+    if (pending_exception_)
+    {
+      std::exception_ptr ex = std::exchange(pending_exception_, nullptr);
+      std::rethrow_exception(ex);
+    }
+  }
+
+private:
+  std::size_t ref_count_ = 0;
+  std::exception_ptr pending_exception_ = nullptr;
+  alignas(Executor) unsigned char executor_[sizeof(Executor)];
+  bool has_executor_ = false;
+};
+
+// Base promise for coroutines further down the thread-of-execution "stack".
+template <typename Executor>
+class awaitee_base
+{
+public:
+#if !defined(ASIO_DISABLE_AWAITEE_RECYCLING)
+  void* operator new(std::size_t size)
+  {
+    return asio::detail::thread_info_base::allocate(
+        asio::detail::thread_info_base::awaitee_tag(),
+        asio::detail::thread_context::thread_call_stack::top(),
+        size);
+  }
+
+  void operator delete(void* pointer, std::size_t size)
+  {
+    asio::detail::thread_info_base::deallocate(
+        asio::detail::thread_info_base::awaitee_tag(),
+        asio::detail::thread_context::thread_call_stack::top(),
+        pointer, size);
+  }
+#endif // !defined(ASIO_DISABLE_AWAITEE_RECYCLING)
+
+  auto initial_suspend()
+  {
+    return std::experimental::suspend_never();
+  }
+
+  struct final_suspender
+  {
+    awaitee_base* this_;
+
+    bool await_ready() const noexcept
+    {
+      return false;
+    }
+
+    void await_suspend(coroutine_handle<void>)
+    {
+      this_->wake_caller();
+    }
+
+    void await_resume() const noexcept
+    {
+    }
+  };
+
+  auto final_suspend()
+  {
+    return final_suspender{this};
+  }
+
+  void set_except(std::exception_ptr e)
+  {
+    pending_exception_ = e;
+  }
+
+  void unhandled_exception()
+  {
+    set_except(std::current_exception());
+  }
+
+  void rethrow_exception()
+  {
+    if (pending_exception_)
+    {
+      std::exception_ptr ex = std::exchange(pending_exception_, nullptr);
+      std::rethrow_exception(ex);
+    }
+  }
+
+  awaiter<Executor>* top()
+  {
+    return awaiter_;
+  }
+
+  coroutine_handle<void> caller()
+  {
+    return caller_;
+  }
+
+  bool ready() const
+  {
+    return ready_;
+  }
+
+  void wake_caller()
+  {
+    if (caller_)
+      caller_.resume();
+    else
+      ready_ = true;
+  }
+
+  class awaitable_executor
+  {
+  public:
+    explicit awaitable_executor(awaitee_base* a)
+      : this_(a)
+    {
+    }
+
+    bool await_ready() const noexcept
+    {
+      return this_->awaiter_ != nullptr;
+    }
+
+    template <typename U, typename Ex>
+    void await_suspend(coroutine_handle<detail::awaitee<U, Ex>> h) noexcept
+    {
+      this_->resume_on_attach_ = h;
+    }
+
+    Executor await_resume()
+    {
+      return this_->awaiter_->get_executor();
+    }
+
+  private:
+    awaitee_base* this_;
+  };
+
+  awaitable_executor await_transform(this_coro::executor_t) noexcept
+  {
+    return awaitable_executor(this);
+  }
+
+  class awaitable_token
+  {
+  public:
+    explicit awaitable_token(awaitee_base* a)
+      : this_(a)
+    {
+    }
+
+    bool await_ready() const noexcept
+    {
+      return this_->awaiter_ != nullptr;
+    }
+
+    template <typename U, typename Ex>
+    void await_suspend(coroutine_handle<detail::awaitee<U, Ex>> h) noexcept
+    {
+      this_->resume_on_attach_ = h;
+    }
+
+    await_token<Executor> await_resume()
+    {
+      return await_token<Executor>(this_->awaiter_);
+    }
+
+  private:
+    awaitee_base* this_;
+  };
+
+  awaitable_token await_transform(this_coro::token_t) noexcept
+  {
+    return awaitable_token(this);
+  }
+
+  template <typename T>
+  awaitable<T, Executor> await_transform(awaitable<T, Executor>& t) const
+  {
+    return std::move(t);
+  }
+
+  template <typename T>
+  awaitable<T, Executor> await_transform(awaitable<T, Executor>&& t) const
+  {
+    return std::move(t);
+  }
+
+  std::experimental::suspend_always await_transform(
+      std::experimental::suspend_always) const
+  {
+    return std::experimental::suspend_always();
+  }
+
+  void attach_caller(coroutine_handle<awaiter<Executor>> h)
+  {
+    this->caller_ = h;
+    this->attach_callees(&h.promise());
+  }
+
+  template <typename U>
+  void attach_caller(coroutine_handle<awaitee<U, Executor>> h)
+  {
+    this->caller_ = h;
+    if (h.promise().awaiter_)
+      this->attach_callees(h.promise().awaiter_);
+    else
+      h.promise().unattached_callee_ = this;
+  }
+
+  void attach_callees(awaiter<Executor>* a)
+  {
+    for (awaitee_base* curr = this; curr != nullptr;
+        curr = std::exchange(curr->unattached_callee_, nullptr))
+    {
+      curr->awaiter_ = a;
+      if (curr->resume_on_attach_)
+        return std::exchange(curr->resume_on_attach_, nullptr).resume();
+    }
+  }
+
+protected:
+  awaiter<Executor>* awaiter_ = nullptr;
+  coroutine_handle<void> caller_ = nullptr;
+  awaitee_base<Executor>* unattached_callee_ = nullptr;
+  std::exception_ptr pending_exception_ = nullptr;
+  coroutine_handle<void> resume_on_attach_ = nullptr;
+  bool ready_ = false;
+};
+
+// Promise object for coroutines further down the thread-of-execution "stack".
+template <typename T, typename Executor>
+class awaitee
+  : public awaitee_base<Executor>
+{
+public:
+  awaitee()
+  {
+  }
+
+  awaitee(awaitee&& other) noexcept
+    : awaitee_base<Executor>(std::move(other))
+  {
+  }
+
+  ~awaitee()
+  {
+    if (has_result_)
+      static_cast<T*>(static_cast<void*>(result_))->~T();
+  }
+
+  awaitable<T, Executor> get_return_object()
+  {
+    return awaitable<T, Executor>(this);
+  };
+
+  template <typename U>
+  void return_value(U&& u)
+  {
+    new (&result_) T(std::forward<U>(u));
+    has_result_ = true;
+  }
+
+  T get()
+  {
+    this->caller_ = nullptr;
+    this->rethrow_exception();
+    return std::move(*static_cast<T*>(static_cast<void*>(result_)));
+  }
+
+private:
+  alignas(T) unsigned char result_[sizeof(T)];
+  bool has_result_ = false;
+};
+
+// Promise object for coroutines further down the thread-of-execution "stack".
+template <typename Executor>
+class awaitee<void, Executor>
+  : public awaitee_base<Executor>
+{
+public:
+  awaitable<void, Executor> get_return_object()
+  {
+    return awaitable<void, Executor>(this);
+  };
+
+  void return_void()
+  {
+  }
+
+  void get()
+  {
+    this->caller_ = nullptr;
+    this->rethrow_exception();
+  }
+};
+
+template <typename Executor>
+class awaiter_task
+{
+public:
+  typedef Executor executor_type;
+
+  awaiter_task(awaiter<Executor>* a)
+    : awaiter_(a->add_ref())
+  {
+  }
+
+  awaiter_task(awaiter_task&& other) noexcept
+    : awaiter_(std::exchange(other.awaiter_, nullptr))
+  {
+  }
+
+  ~awaiter_task()
+  {
+    if (awaiter_)
+    {
+      // Coroutine "stack unwinding" must be performed through the executor.
+      executor_type ex(awaiter_->get_executor());
+      (post)(ex,
+          [a = std::move(awaiter_)]() mutable
+          {
+            typename awaiter<Executor>::ptr(std::move(a));
+          });
+    }
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return awaiter_->get_executor();
+  }
+
+protected:
+  typename awaiter<Executor>::ptr awaiter_;
+};
+
+template <typename Executor>
+class co_spawn_handler : public awaiter_task<Executor>
+{
+public:
+  using awaiter_task<Executor>::awaiter_task;
+
+  void operator()()
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    coroutine_handle<awaiter<Executor>>::from_promise(*ptr.get()).resume();
+  }
+};
+
+template <typename Executor, typename T>
+class await_handler_base : public awaiter_task<Executor>
+{
+public:
+  typedef awaitable<T, Executor> awaitable_type;
+
+  await_handler_base(await_token<Executor> token)
+    : awaiter_task<Executor>(token.awaiter_),
+      awaitee_(nullptr)
+  {
+  }
+
+  await_handler_base(await_handler_base&& other) noexcept
+    : awaiter_task<Executor>(std::move(other)),
+      awaitee_(std::exchange(other.awaitee_, nullptr))
+  {
+  }
+
+  void attach_awaitee(const awaitable<T, Executor>& a)
+  {
+    awaitee_ = a.awaitee_;
+  }
+
+protected:
+  awaitee<T, Executor>* awaitee_;
+};
+
+template <typename, typename...> class await_handler;
+
+template <typename Executor>
+class await_handler<Executor, void>
+  : public await_handler_base<Executor, void>
+{
+public:
+  using await_handler_base<Executor, void>::await_handler_base;
+
+  void operator()()
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    this->awaitee_->return_void();
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor>
+class await_handler<Executor, asio::error_code>
+  : public await_handler_base<Executor, void>
+{
+public:
+  typedef void return_type;
+
+  using await_handler_base<Executor, void>::await_handler_base;
+
+  void operator()(const asio::error_code& ec)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    if (ec)
+    {
+      this->awaitee_->set_except(
+          std::make_exception_ptr(asio::system_error(ec)));
+    }
+    else
+      this->awaitee_->return_void();
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor>
+class await_handler<Executor, std::exception_ptr>
+  : public await_handler_base<Executor, void>
+{
+public:
+  using await_handler_base<Executor, void>::await_handler_base;
+
+  void operator()(std::exception_ptr ex)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    if (ex)
+      this->awaitee_->set_except(ex);
+    else
+      this->awaitee_->return_void();
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor, typename T>
+class await_handler<Executor, T>
+  : public await_handler_base<Executor, T>
+{
+public:
+  using await_handler_base<Executor, T>::await_handler_base;
+
+  template <typename Arg>
+  void operator()(Arg&& arg)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    this->awaitee_->return_value(std::forward<Arg>(arg));
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor, typename T>
+class await_handler<Executor, asio::error_code, T>
+  : public await_handler_base<Executor, T>
+{
+public:
+  using await_handler_base<Executor, T>::await_handler_base;
+
+  template <typename Arg>
+  void operator()(const asio::error_code& ec, Arg&& arg)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    if (ec)
+    {
+      this->awaitee_->set_except(
+          std::make_exception_ptr(asio::system_error(ec)));
+    }
+    else
+      this->awaitee_->return_value(std::forward<Arg>(arg));
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor, typename T>
+class await_handler<Executor, std::exception_ptr, T>
+  : public await_handler_base<Executor, T>
+{
+public:
+  using await_handler_base<Executor, T>::await_handler_base;
+
+  template <typename Arg>
+  void operator()(std::exception_ptr ex, Arg&& arg)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    if (ex)
+      this->awaitee_->set_except(ex);
+    else
+      this->awaitee_->return_value(std::forward<Arg>(arg));
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor, typename... Ts>
+class await_handler
+  : public await_handler_base<Executor, std::tuple<Ts...>>
+{
+public:
+  using await_handler_base<Executor, std::tuple<Ts...>>::await_handler_base;
+
+  template <typename... Args>
+  void operator()(Args&&... args)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    this->awaitee_->return_value(
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor, typename... Ts>
+class await_handler<Executor, asio::error_code, Ts...>
+  : public await_handler_base<Executor, std::tuple<Ts...>>
+{
+public:
+  using await_handler_base<Executor, std::tuple<Ts...>>::await_handler_base;
+
+  template <typename... Args>
+  void operator()(const asio::error_code& ec, Args&&... args)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    if (ec)
+    {
+      this->awaitee_->set_except(
+          std::make_exception_ptr(asio::system_error(ec)));
+    }
+    else
+    {
+      this->awaitee_->return_value(
+          std::forward_as_tuple(std::forward<Args>(args)...));
+    }
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename Executor, typename... Ts>
+class await_handler<Executor, std::exception_ptr, Ts...>
+  : public await_handler_base<Executor, std::tuple<Ts...>>
+{
+public:
+  using await_handler_base<Executor, std::tuple<Ts...>>::await_handler_base;
+
+  template <typename... Args>
+  void operator()(std::exception_ptr ex, Args&&... args)
+  {
+    typename awaiter<Executor>::ptr ptr(std::move(this->awaiter_));
+    if (ex)
+      this->awaitee_->set_except(ex);
+    else
+    {
+      this->awaitee_->return_value(
+          std::forward_as_tuple(std::forward<Args>(args)...));
+    }
+    this->awaitee_->wake_caller();
+    ptr->rethrow_unhandled_exception();
+  }
+};
+
+template <typename T>
+struct awaitable_signature;
+
+template <typename T, typename Executor>
+struct awaitable_signature<awaitable<T, Executor>>
+{
+  typedef void type(std::exception_ptr, T);
+};
+
+template <typename Executor>
+struct awaitable_signature<awaitable<void, Executor>>
+{
+  typedef void type(std::exception_ptr);
+};
+
+template <typename T, typename Executor, typename F, typename Handler>
+awaiter<Executor>* co_spawn_entry_point(awaitable<T, Executor>*,
+    executor_work_guard<Executor> work_guard, F f, Handler handler)
+{
+  bool done = false;
+
+  try
+  {
+    T t = co_await f();
+
+    done = true;
+
+    (dispatch)(work_guard.get_executor(),
+        [handler = std::move(handler), t = std::move(t)]() mutable
+        {
+          handler(std::exception_ptr(), std::move(t));
+        });
+  }
+  catch (...)
+  {
+    if (done)
+      throw;
+
+    (dispatch)(work_guard.get_executor(),
+        [handler = std::move(handler), e = std::current_exception()]() mutable
+        {
+          handler(e, T());
+        });
+  }
+}
+
+template <typename Executor, typename F, typename Handler>
+awaiter<Executor>* co_spawn_entry_point(awaitable<void, Executor>*,
+    executor_work_guard<Executor> work_guard, F f, Handler handler)
+{
+  std::exception_ptr e = nullptr;
+
+  try
+  {
+    co_await f();
+  }
+  catch (...)
+  {
+    e = std::current_exception();
+  }
+
+  (dispatch)(work_guard.get_executor(),
+      [handler = std::move(handler), e]() mutable
+      {
+        handler(e);
+      });
+}
+
+template <typename Executor, typename F, typename CompletionToken>
+auto co_spawn(const Executor& ex, F&& f, CompletionToken&& token)
+{
+  typedef typename result_of<F()>::type awaitable_type;
+  typedef typename awaitable_type::executor_type executor_type;
+  typedef typename awaitable_signature<awaitable_type>::type signature_type;
+
+  async_completion<CompletionToken, signature_type> completion(token);
+
+  executor_type ex2(ex);
+  auto work_guard = make_work_guard(completion.completion_handler, ex2);
+
+  auto* a = (co_spawn_entry_point)(
+      static_cast<awaitable_type*>(nullptr), std::move(work_guard),
+      std::forward<F>(f), std::move(completion.completion_handler));
+
+  a->set_executor(ex2);
+  (post)(co_spawn_handler<executor_type>(a));
+
+  return completion.result.get();
+}
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable:4033)
+#endif // defined(_MSC_VER)
+
+#if defined(_MSC_VER)
+template <typename T> T dummy_return()
+{
+  return std::move(*static_cast<T*>(nullptr));
+}
+
+template <>
+inline void dummy_return()
+{
+}
+#endif // defined(_MSC_VER)
+
+template <typename Awaitable>
+inline Awaitable make_dummy_awaitable()
+{
+  for (;;) co_await std::experimental::suspend_always();
+#if defined(_MSC_VER)
+  co_return dummy_return<typename Awaitable::value_type>();
+#endif // defined(_MSC_VER)
+}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif // defined(_MSC_VER)
+
+} // namespace detail
+} // namespace experimental
+
+template <typename Executor, typename R, typename... Args>
+class async_result<experimental::await_token<Executor>, R(Args...)>
+{
+public:
+  typedef experimental::detail::await_handler<
+    Executor, typename decay<Args>::type...> completion_handler_type;
+
+  typedef typename experimental::detail::await_handler<
+    Executor, Args...>::awaitable_type return_type;
+
+  async_result(completion_handler_type& h)
+    : awaitable_(experimental::detail::make_dummy_awaitable<return_type>())
+  {
+    h.attach_awaitee(awaitable_);
+  }
+
+  return_type get()
+  {
+    return std::move(awaitable_);
+  }
+
+private:
+  return_type awaitable_;
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+template <typename Executor, typename R, typename... Args>
+struct handler_type<experimental::await_token<Executor>, R(Args...)>
+{
+  typedef experimental::detail::await_handler<
+    Executor, typename decay<Args>::type...> type;
+};
+
+template <typename Executor, typename... Args>
+class async_result<experimental::detail::await_handler<Executor, Args...>>
+{
+public:
+  typedef typename experimental::detail::await_handler<
+    Executor, Args...>::awaitable_type type;
+
+  async_result(experimental::detail::await_handler<Executor, Args...>& h)
+    : awaitable_(experimental::detail::make_dummy_awaitable<type>())
+  {
+    h.attach_awaitee(awaitable_);
+  }
+
+  type get()
+  {
+    return std::move(awaitable_);
+  }
+
+private:
+  type awaitable_;
+};
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+} // namespace asio
+
+namespace std { namespace experimental {
+
+template <typename Executor, typename... Args>
+struct coroutine_traits<
+  asio::experimental::detail::awaiter<Executor>*, Args...>
+{
+  typedef asio::experimental::detail::awaiter<Executor> promise_type;
+};
+
+template <typename T, typename Executor, typename... Args>
+struct coroutine_traits<
+  asio::experimental::awaitable<T, Executor>, Args...>
+{
+  typedef asio::experimental::detail::awaitee<T, Executor> promise_type;
+};
+
+}} // namespace std::experimental
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXPERIMENTAL_IMPL_CO_SPAWN_HPP
diff --git a/extern/include/asio/experimental/impl/detached.hpp b/extern/include/asio/experimental/impl/detached.hpp
new file mode 100644
index 00000000..6ce88872
--- /dev/null
+++ b/extern/include/asio/experimental/impl/detached.hpp
@@ -0,0 +1,91 @@
+//
+// experimental/impl/detached.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXPERIMENTAL_IMPL_DETACHED_HPP
+#define ASIO_EXPERIMENTAL_IMPL_DETACHED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/async_result.hpp"
+#include "asio/detail/variadic_templates.hpp"
+#include "asio/handler_type.hpp"
+#include "asio/system_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace experimental {
+namespace detail {
+
+  // Class to adapt a detached_t as a completion handler.
+  class detached_handler
+  {
+  public:
+    detached_handler(detached_t)
+    {
+    }
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename... Args>
+    void operator()(Args...)
+    {
+    }
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+    void operator()()
+    {
+    }
+
+#define ASIO_PRIVATE_DETACHED_DEF(n) \
+    template <ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()(ASIO_VARIADIC_BYVAL_PARAMS(n)) \
+    { \
+    } \
+    /**/
+    ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_DETACHED_DEF)
+#undef ASIO_PRIVATE_DETACHED_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+  };
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Signature>
+struct async_result<experimental::detached_t, Signature>
+{
+  typedef asio::experimental::detail::detached_handler
+    completion_handler_type;
+
+  typedef void return_type;
+
+  explicit async_result(completion_handler_type&)
+  {
+  }
+
+  void get()
+  {
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXPERIMENTAL_IMPL_DETACHED_HPP
diff --git a/extern/include/asio/experimental/impl/redirect_error.hpp b/extern/include/asio/experimental/impl/redirect_error.hpp
new file mode 100644
index 00000000..d3b97fac
--- /dev/null
+++ b/extern/include/asio/experimental/impl/redirect_error.hpp
@@ -0,0 +1,294 @@
+//
+// experimental/impl/redirect_error.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXPERIMENTAL_IMPL_REDIRECT_ERROR_HPP
+#define ASIO_EXPERIMENTAL_IMPL_REDIRECT_ERROR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/async_result.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_cont_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/detail/variadic_templates.hpp"
+#include "asio/handler_type.hpp"
+#include "asio/system_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Class to adapt a redirect_error_t as a completion handler.
+template <typename Handler>
+class redirect_error_handler
+{
+public:
+  template <typename CompletionToken>
+  redirect_error_handler(redirect_error_t<CompletionToken> e)
+    : ec_(e.ec_),
+      handler_(ASIO_MOVE_CAST(CompletionToken)(e.token_))
+  {
+  }
+
+  void operator()()
+  {
+    handler_();
+  }
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Arg, typename... Args>
+  typename enable_if<
+    !is_same<typename decay<Arg>::type, asio::error_code>::value
+  >::type
+  operator()(ASIO_MOVE_ARG(Arg) arg, ASIO_MOVE_ARG(Args)... args)
+  {
+    handler_(ASIO_MOVE_CAST(Arg)(arg),
+        ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  template <typename... Args>
+  void operator()(const asio::error_code& ec,
+      ASIO_MOVE_ARG(Args)... args)
+  {
+    ec_ = ec;
+    handler_(ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Arg>
+  typename enable_if<
+    !is_same<typename decay<Arg>::type, asio::error_code>::value
+  >::type
+  operator()(ASIO_MOVE_ARG(Arg) arg)
+  {
+    handler_(ASIO_MOVE_CAST(Arg)(arg));
+  }
+
+  void operator()(const asio::error_code& ec)
+  {
+    ec_ = ec;
+    handler_();
+  }
+
+#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \
+  template <typename Arg, ASIO_VARIADIC_TPARAMS(n)> \
+  typename enable_if< \
+    !is_same<typename decay<Arg>::type, asio::error_code>::value \
+  >::type \
+  operator()(ASIO_MOVE_ARG(Arg) arg, ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    handler_(ASIO_MOVE_CAST(Arg)(arg), \
+        ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  void operator()(const asio::error_code& ec, \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    ec_ = ec; \
+    handler_(ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_REDIRECT_ERROR_DEF)
+#undef ASIO_PRIVATE_REDIRECT_ERROR_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+//private:
+  asio::error_code& ec_;
+  Handler handler_;
+};
+
+template <typename Handler>
+inline void* asio_handler_allocate(std::size_t size,
+    redirect_error_handler<Handler>* this_handler)
+{
+  return asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+}
+
+template <typename Handler>
+inline void asio_handler_deallocate(void* pointer, std::size_t size,
+    redirect_error_handler<Handler>* this_handler)
+{
+  asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    redirect_error_handler<Handler>* this_handler)
+{
+  return asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline void asio_handler_invoke(Function& function,
+    redirect_error_handler<Handler>* this_handler)
+{
+  asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline void asio_handler_invoke(const Function& function,
+    redirect_error_handler<Handler>* this_handler)
+{
+  asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+}
+
+template <typename Signature>
+struct redirect_error_signature
+{
+  typedef Signature type;
+};
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename R, typename... Args>
+struct redirect_error_signature<R(asio::error_code, Args...)>
+{
+  typedef R type(Args...);
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<R(const asio::error_code&, Args...)>
+{
+  typedef R type(Args...);
+};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename R>
+struct redirect_error_signature<R(asio::error_code)>
+{
+  typedef R type();
+};
+
+template <typename R>
+struct redirect_error_signature<R(const asio::error_code&)>
+{
+  typedef R type();
+};
+
+#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \
+  template <typename R, ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(asio::error_code, ASIO_VARIADIC_TARGS(n))> \
+  { \
+    typedef R type(ASIO_VARIADIC_TARGS(n)); \
+  }; \
+  \
+  template <typename R, ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(const asio::error_code&, ASIO_VARIADIC_TARGS(n))> \
+  { \
+    typedef R type(ASIO_VARIADIC_TARGS(n)); \
+  }; \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_REDIRECT_ERROR_DEF)
+#undef ASIO_PRIVATE_REDIRECT_ERROR_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken, typename Signature>
+struct async_result<experimental::redirect_error_t<CompletionToken>, Signature>
+  : async_result<CompletionToken,
+      typename experimental::detail::redirect_error_signature<Signature>::type>
+{
+  typedef experimental::detail::redirect_error_handler<
+    typename async_result<CompletionToken,
+      typename experimental::detail::redirect_error_signature<Signature>::type>
+        ::completion_handler_type> completion_handler_type;
+
+  explicit async_result(completion_handler_type& h)
+    : async_result<CompletionToken,
+        typename experimental::detail::redirect_error_signature<
+          Signature>::type>(h.handler_)
+  {
+  }
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+template <typename CompletionToken, typename Signature>
+struct handler_type<experimental::redirect_error_t<CompletionToken>, Signature>
+{
+  typedef experimental::detail::redirect_error_handler<
+    typename async_result<CompletionToken,
+      typename experimental::detail::redirect_error_signature<Signature>::type>
+        ::completion_handler_type> type;
+};
+
+template <typename Handler>
+struct async_result<experimental::detail::redirect_error_handler<Handler> >
+  : async_result<Handler>
+{
+  explicit async_result(
+      experimental::detail::redirect_error_handler<Handler>& h)
+    : async_result<Handler>(h.handler_)
+  {
+  }
+};
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+template <typename Handler, typename Executor>
+struct associated_executor<
+    experimental::detail::redirect_error_handler<Handler>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
+
+  static type get(
+      const experimental::detail::redirect_error_handler<Handler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+  }
+};
+
+template <typename Handler, typename Allocator>
+struct associated_allocator<
+    experimental::detail::redirect_error_handler<Handler>, Allocator>
+{
+  typedef typename associated_allocator<Handler, Allocator>::type type;
+
+  static type get(
+      const experimental::detail::redirect_error_handler<Handler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXPERIMENTAL_IMPL_REDIRECT_ERROR_HPP
diff --git a/extern/include/asio/experimental/redirect_error.hpp b/extern/include/asio/experimental/redirect_error.hpp
new file mode 100644
index 00000000..30e81cf5
--- /dev/null
+++ b/extern/include/asio/experimental/redirect_error.hpp
@@ -0,0 +1,67 @@
+//
+// experimental/redirect_error.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_EXPERIMENTAL_REDIRECT_ERROR_HPP
+#define ASIO_EXPERIMENTAL_REDIRECT_ERROR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/error_code.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace experimental {
+
+/// Completion token type used to specify that an error produced by an
+/// asynchronous operation is captured to an error_code variable.
+/**
+ * The redirect_error_t class is used to indicate that any error_code produced
+ * by an asynchronous operation is captured to a specified variable.
+ */
+template <typename CompletionToken>
+class redirect_error_t
+{
+public:
+  /// Constructor. 
+  template <typename T>
+  redirect_error_t(ASIO_MOVE_ARG(T) completion_token,
+      asio::error_code& ec)
+    : token_(ASIO_MOVE_CAST(T)(completion_token)),
+      ec_(ec)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  asio::error_code& ec_;
+};
+
+/// Create a completion token to capture error_code values to a variable.
+template <typename CompletionToken>
+inline redirect_error_t<typename decay<CompletionToken>::type> redirect_error(
+    CompletionToken&& completion_token, asio::error_code& ec)
+{
+  return redirect_error_t<typename decay<CompletionToken>::type>(
+      ASIO_MOVE_CAST(CompletionToken)(completion_token), ec);
+}
+
+} // namespace experimental
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/experimental/impl/redirect_error.hpp"
+
+#endif // ASIO_EXPERIMENTAL_REDIRECT_ERROR_HPP
diff --git a/extern/include/asio/generic/basic_endpoint.hpp b/extern/include/asio/generic/basic_endpoint.hpp
index 9f5fbce5..73aa151d 100644
--- a/extern/include/asio/generic/basic_endpoint.hpp
+++ b/extern/include/asio/generic/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // generic/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/generic/datagram_protocol.hpp b/extern/include/asio/generic/datagram_protocol.hpp
index 1cfd4f9e..8678ad85 100644
--- a/extern/include/asio/generic/datagram_protocol.hpp
+++ b/extern/include/asio/generic/datagram_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/datagram_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/generic/detail/endpoint.hpp b/extern/include/asio/generic/detail/endpoint.hpp
index d2eedec8..190beb14 100644
--- a/extern/include/asio/generic/detail/endpoint.hpp
+++ b/extern/include/asio/generic/detail/endpoint.hpp
@@ -2,7 +2,7 @@
 // generic/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/generic/detail/impl/endpoint.ipp b/extern/include/asio/generic/detail/impl/endpoint.ipp
index 7261819b..227ffe1e 100644
--- a/extern/include/asio/generic/detail/impl/endpoint.ipp
+++ b/extern/include/asio/generic/detail/impl/endpoint.ipp
@@ -2,7 +2,7 @@
 // generic/detail/impl/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -94,7 +94,8 @@ void endpoint::init(const void* sock_addr,
 
   using namespace std; // For memset and memcpy.
   memset(&data_.generic, 0, sizeof(asio::detail::sockaddr_storage_type));
-  memcpy(&data_.generic, sock_addr, sock_addr_size);
+  if (sock_addr_size > 0)
+    memcpy(&data_.generic, sock_addr, sock_addr_size);
 
   size_ = sock_addr_size;
   protocol_ = sock_protocol;
diff --git a/extern/include/asio/generic/raw_protocol.hpp b/extern/include/asio/generic/raw_protocol.hpp
index b5632580..b83dca6e 100644
--- a/extern/include/asio/generic/raw_protocol.hpp
+++ b/extern/include/asio/generic/raw_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/raw_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/generic/seq_packet_protocol.hpp b/extern/include/asio/generic/seq_packet_protocol.hpp
index ea55ce6c..f92a4c8f 100644
--- a/extern/include/asio/generic/seq_packet_protocol.hpp
+++ b/extern/include/asio/generic/seq_packet_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/seq_packet_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/generic/stream_protocol.hpp b/extern/include/asio/generic/stream_protocol.hpp
index 7f457b33..8349f25b 100644
--- a/extern/include/asio/generic/stream_protocol.hpp
+++ b/extern/include/asio/generic/stream_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/stream_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/handler_alloc_hook.hpp b/extern/include/asio/handler_alloc_hook.hpp
index 8d992cab..d7fe2b01 100644
--- a/extern/include/asio/handler_alloc_hook.hpp
+++ b/extern/include/asio/handler_alloc_hook.hpp
@@ -2,7 +2,7 @@
 // handler_alloc_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/handler_continuation_hook.hpp b/extern/include/asio/handler_continuation_hook.hpp
index fd6051e0..d41d1059 100644
--- a/extern/include/asio/handler_continuation_hook.hpp
+++ b/extern/include/asio/handler_continuation_hook.hpp
@@ -2,7 +2,7 @@
 // handler_continuation_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/handler_invoke_hook.hpp b/extern/include/asio/handler_invoke_hook.hpp
index 8a2ed43a..ee618e5e 100644
--- a/extern/include/asio/handler_invoke_hook.hpp
+++ b/extern/include/asio/handler_invoke_hook.hpp
@@ -2,7 +2,7 @@
 // handler_invoke_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -26,12 +26,12 @@ namespace asio {
  * @brief Default invoke function for handlers.
  *
  * Completion handlers for asynchronous operations are invoked by the
- * io_service associated with the corresponding object (e.g. a socket or
+ * io_context associated with the corresponding object (e.g. a socket or
  * deadline_timer). Certain guarantees are made on when the handler may be
  * invoked, in particular that a handler can only be invoked from a thread that
- * is currently calling @c run() on the corresponding io_service object.
+ * is currently calling @c run() on the corresponding io_context object.
  * Handlers may subsequently be invoked through other objects (such as
- * io_service::strand objects) that provide additional guarantees.
+ * io_context::strand objects) that provide additional guarantees.
  *
  * When asynchronous operations are composed from other asynchronous
  * operations, all intermediate handlers should be invoked using the same
diff --git a/extern/include/asio/handler_type.hpp b/extern/include/asio/handler_type.hpp
index 56f75b6e..bc0d3051 100644
--- a/extern/include/asio/handler_type.hpp
+++ b/extern/include/asio/handler_type.hpp
@@ -2,7 +2,7 @@
 // handler_type.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,97 +16,35 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 
-/// Default handler type traits provided for all handlers.
+/// (Deprecated: Use two-parameter version of async_result.) Default handler
+/// type traits provided for all completion token types.
 /**
  * The handler_type traits class is used for determining the concrete handler
  * type to be used for an asynchronous operation. It allows the handler type to
  * be determined at the point where the specific completion handler signature
  * is known.
  *
- * This template may be specialised for user-defined handler types.
+ * This template may be specialised for user-defined completion token types.
  */
-template <typename Handler, typename Signature>
+template <typename CompletionToken, typename Signature, typename = void>
 struct handler_type
 {
   /// The handler type for the specific signature.
-  typedef Handler type;
+  typedef typename conditional<
+    is_same<CompletionToken, typename decay<CompletionToken>::type>::value,
+    decay<CompletionToken>,
+    handler_type<typename decay<CompletionToken>::type, Signature>
+  >::type::type type;
 };
 
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Handler, typename Signature>
-struct handler_type<const Handler, Signature>
-  : handler_type<Handler, Signature> {};
-
-template <typename Handler, typename Signature>
-struct handler_type<volatile Handler, Signature>
-  : handler_type<Handler, Signature> {};
-
-template <typename Handler, typename Signature>
-struct handler_type<const volatile Handler, Signature>
-  : handler_type<Handler, Signature> {};
-
-template <typename Handler, typename Signature>
-struct handler_type<const Handler&, Signature>
-  : handler_type<Handler, Signature> {};
-
-template <typename Handler, typename Signature>
-struct handler_type<volatile Handler&, Signature>
-  : handler_type<Handler, Signature> {};
-
-template <typename Handler, typename Signature>
-struct handler_type<const volatile Handler&, Signature>
-  : handler_type<Handler, Signature> {};
-
-template <typename Handler, typename Signature>
-struct handler_type<Handler&, Signature>
-  : handler_type<Handler, Signature> {};
-
-#if defined(ASIO_HAS_MOVE)
-template <typename Handler, typename Signature>
-struct handler_type<Handler&&, Signature>
-  : handler_type<Handler, Signature> {};
-#endif // defined(ASIO_HAS_MOVE)
-
-template <typename ReturnType, typename Signature>
-struct handler_type<ReturnType(), Signature>
-  : handler_type<ReturnType(*)(), Signature> {};
-
-template <typename ReturnType, typename Arg1, typename Signature>
-struct handler_type<ReturnType(Arg1), Signature>
-  : handler_type<ReturnType(*)(Arg1), Signature> {};
-
-template <typename ReturnType, typename Arg1, typename Arg2, typename Signature>
-struct handler_type<ReturnType(Arg1, Arg2), Signature>
-  : handler_type<ReturnType(*)(Arg1, Arg2), Signature> {};
-
-template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
-    typename Signature>
-struct handler_type<ReturnType(Arg1, Arg2, Arg3), Signature>
-  : handler_type<ReturnType(*)(Arg1, Arg2, Arg3), Signature> {};
-
-template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Signature>
-struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4), Signature>
-  : handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4), Signature> {};
-
-template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5, typename Signature>
-struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4, Arg5), Signature>
-  : handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4, Arg5), Signature> {};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
-#define ASIO_HANDLER_TYPE(h, sig) \
-  typename handler_type<h, sig>::type
-
 #endif // ASIO_HANDLER_TYPE_HPP
diff --git a/extern/include/asio/high_resolution_timer.hpp b/extern/include/asio/high_resolution_timer.hpp
index 6ab1324f..0549cc25 100644
--- a/extern/include/asio/high_resolution_timer.hpp
+++ b/extern/include/asio/high_resolution_timer.hpp
@@ -2,7 +2,7 @@
 // high_resolution_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,21 +17,13 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_HAS_STD_CHRONO) \
-  || defined(ASIO_HAS_BOOST_CHRONO) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#if defined(ASIO_HAS_STD_CHRONO)
-# include <chrono>
-#elif defined(ASIO_HAS_BOOST_CHRONO)
-# include <boost/chrono/system_clocks.hpp>
-#endif
+#if defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
 
 #include "asio/basic_waitable_timer.hpp"
+#include "asio/detail/chrono.hpp"
 
 namespace asio {
 
-#if defined(GENERATING_DOCUMENTATION)
 /// Typedef for a timer based on the high resolution clock.
 /**
  * This typedef uses the C++11 @c &lt;chrono&gt; standard library facility, if
@@ -44,20 +36,9 @@ namespace asio {
 typedef basic_waitable_timer<
     chrono::high_resolution_clock>
   high_resolution_timer;
-#elif defined(ASIO_HAS_STD_CHRONO)
-typedef basic_waitable_timer<
-    std::chrono::high_resolution_clock>
-  high_resolution_timer;
-#elif defined(ASIO_HAS_BOOST_CHRONO)
-typedef basic_waitable_timer<
-    boost::chrono::high_resolution_clock>
-  high_resolution_timer;
-#endif
 
 } // namespace asio
 
-#endif // defined(ASIO_HAS_STD_CHRONO) 
-       //   || defined(ASIO_HAS_BOOST_CHRONO)
-       //   || defined(GENERATING_DOCUMENTATION)
+#endif // defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
 
 #endif // ASIO_HIGH_RESOLUTION_TIMER_HPP
diff --git a/extern/include/asio/impl/buffered_read_stream.hpp b/extern/include/asio/impl/buffered_read_stream.hpp
index 41bfd942..e0ed20e4 100644
--- a/extern/include/asio/impl/buffered_read_stream.hpp
+++ b/extern/include/asio/impl/buffered_read_stream.hpp
@@ -2,7 +2,7 @@
 // impl/buffered_read_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
@@ -137,6 +139,36 @@ namespace detail
   }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::buffered_fill_handler<ReadHandler>, Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(const detail::buffered_fill_handler<ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::buffered_fill_handler<ReadHandler>, Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(const detail::buffered_fill_handler<ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename Stream>
 template <typename ReadHandler>
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
@@ -148,9 +180,8 @@ buffered_read_stream<Stream>::async_fill(
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   std::size_t previous_size = storage_.size();
   storage_.resize(storage_.capacity());
@@ -160,7 +191,7 @@ buffered_read_stream<Stream>::async_fill(
         storage_.size() - previous_size),
       detail::buffered_fill_handler<ASIO_HANDLER_TYPE(
         ReadHandler, void (asio::error_code, std::size_t))>(
-        storage_, previous_size, init.handler));
+        storage_, previous_size, init.completion_handler));
 
   return init.result.get();
 }
@@ -170,7 +201,8 @@ template <typename MutableBufferSequence>
 std::size_t buffered_read_stream<Stream>::read_some(
     const MutableBufferSequence& buffers)
 {
-  if (asio::buffer_size(buffers) == 0)
+  using asio::buffer_size;
+  if (buffer_size(buffers) == 0)
     return 0;
 
   if (storage_.empty())
@@ -186,7 +218,8 @@ std::size_t buffered_read_stream<Stream>::read_some(
 {
   ec = asio::error_code();
 
-  if (asio::buffer_size(buffers) == 0)
+  using asio::buffer_size;
+  if (buffer_size(buffers) == 0)
     return 0;
 
   if (storage_.empty() && !this->fill(ec))
@@ -205,7 +238,7 @@ namespace detail
         const MutableBufferSequence& buffers, ReadHandler& handler)
       : storage_(storage),
         buffers_(buffers),
-        handler_(handler)
+        handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
@@ -295,6 +328,44 @@ namespace detail
   }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename MutableBufferSequence,
+    typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename MutableBufferSequence,
+    typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename Stream>
 template <typename MutableBufferSequence, typename ReadHandler>
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
@@ -307,24 +378,24 @@ buffered_read_stream<Stream>::async_read_some(
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  if (asio::buffer_size(buffers) == 0 || !storage_.empty())
+  using asio::buffer_size;
+  if (buffer_size(buffers) == 0 || !storage_.empty())
   {
-    next_layer_.async_read_some(asio::mutable_buffers_1(0, 0),
+    next_layer_.async_read_some(ASIO_MUTABLE_BUFFER(0, 0),
         detail::buffered_read_some_handler<
           MutableBufferSequence, ASIO_HANDLER_TYPE(
             ReadHandler, void (asio::error_code, std::size_t))>(
-            storage_, buffers, init.handler));
+            storage_, buffers, init.completion_handler));
   }
   else
   {
     this->async_fill(detail::buffered_read_some_handler<
           MutableBufferSequence, ASIO_HANDLER_TYPE(
             ReadHandler, void (asio::error_code, std::size_t))>(
-            storage_, buffers, init.handler));
+            storage_, buffers, init.completion_handler));
   }
 
   return init.result.get();
diff --git a/extern/include/asio/impl/buffered_write_stream.hpp b/extern/include/asio/impl/buffered_write_stream.hpp
index 4a307cf7..bc2d823a 100644
--- a/extern/include/asio/impl/buffered_write_stream.hpp
+++ b/extern/include/asio/impl/buffered_write_stream.hpp
@@ -2,7 +2,7 @@
 // impl/buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
@@ -52,7 +54,7 @@ namespace detail
     buffered_flush_handler(detail::buffered_stream_storage& storage,
         WriteHandler& handler)
       : storage_(storage),
-        handler_(handler)
+        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
@@ -121,7 +123,37 @@ namespace detail
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-}
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename WriteHandler, typename Allocator>
+struct associated_allocator<
+    detail::buffered_flush_handler<WriteHandler>, Allocator>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+
+  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename WriteHandler, typename Executor>
+struct associated_executor<
+    detail::buffered_flush_handler<WriteHandler>, Executor>
+{
+  typedef typename associated_executor<WriteHandler, Executor>::type type;
+
+  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
 
 template <typename Stream>
 template <typename WriteHandler>
@@ -134,14 +166,13 @@ buffered_write_stream<Stream>::async_flush(
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   async_write(next_layer_, buffer(storage_.data(), storage_.size()),
       detail::buffered_flush_handler<ASIO_HANDLER_TYPE(
         WriteHandler, void (asio::error_code, std::size_t))>(
-        storage_, init.handler));
+        storage_, init.completion_handler));
 
   return init.result.get();
 }
@@ -151,7 +182,8 @@ template <typename ConstBufferSequence>
 std::size_t buffered_write_stream<Stream>::write_some(
     const ConstBufferSequence& buffers)
 {
-  if (asio::buffer_size(buffers) == 0)
+  using asio::buffer_size;
+  if (buffer_size(buffers) == 0)
     return 0;
 
   if (storage_.size() == storage_.capacity())
@@ -167,7 +199,8 @@ std::size_t buffered_write_stream<Stream>::write_some(
 {
   ec = asio::error_code();
 
-  if (asio::buffer_size(buffers) == 0)
+  using asio::buffer_size;
+  if (buffer_size(buffers) == 0)
     return 0;
 
   if (storage_.size() == storage_.capacity() && !flush(ec))
@@ -186,7 +219,7 @@ namespace detail
         const ConstBufferSequence& buffers, WriteHandler& handler)
       : storage_(storage),
         buffers_(buffers),
-        handler_(handler)
+        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
@@ -215,9 +248,10 @@ namespace detail
       }
       else
       {
+        using asio::buffer_size;
         std::size_t orig_size = storage_.size();
         std::size_t space_avail = storage_.capacity() - orig_size;
-        std::size_t bytes_avail = asio::buffer_size(buffers_);
+        std::size_t bytes_avail = buffer_size(buffers_);
         std::size_t length = bytes_avail < space_avail
           ? bytes_avail : space_avail;
         storage_.resize(orig_size + length);
@@ -281,6 +315,44 @@ namespace detail
   }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename ConstBufferSequence,
+    typename WriteHandler, typename Allocator>
+struct associated_allocator<
+    detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+
+  static type get(
+      const detail::buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename ConstBufferSequence,
+    typename WriteHandler, typename Executor>
+struct associated_executor<
+    detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
+    Executor>
+{
+  typedef typename associated_executor<WriteHandler, Executor>::type type;
+
+  static type get(
+      const detail::buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename Stream>
 template <typename ConstBufferSequence, typename WriteHandler>
 ASIO_INITFN_RESULT_TYPE(WriteHandler,
@@ -293,25 +365,25 @@ buffered_write_stream<Stream>::async_write_some(
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  if (asio::buffer_size(buffers) == 0
+  using asio::buffer_size;
+  if (buffer_size(buffers) == 0
       || storage_.size() < storage_.capacity())
   {
-    next_layer_.async_write_some(asio::const_buffers_1(0, 0),
+    next_layer_.async_write_some(ASIO_CONST_BUFFER(0, 0),
         detail::buffered_write_some_handler<
           ConstBufferSequence, ASIO_HANDLER_TYPE(
             WriteHandler, void (asio::error_code, std::size_t))>(
-            storage_, buffers, init.handler));
+            storage_, buffers, init.completion_handler));
   }
   else
   {
     this->async_flush(detail::buffered_write_some_handler<
           ConstBufferSequence, ASIO_HANDLER_TYPE(
             WriteHandler, void (asio::error_code, std::size_t))>(
-            storage_, buffers, init.handler));
+            storage_, buffers, init.completion_handler));
   }
 
   return init.result.get();
@@ -322,9 +394,10 @@ template <typename ConstBufferSequence>
 std::size_t buffered_write_stream<Stream>::copy(
     const ConstBufferSequence& buffers)
 {
+  using asio::buffer_size;
   std::size_t orig_size = storage_.size();
   std::size_t space_avail = storage_.capacity() - orig_size;
-  std::size_t bytes_avail = asio::buffer_size(buffers);
+  std::size_t bytes_avail = buffer_size(buffers);
   std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
   storage_.resize(orig_size + length);
   return asio::buffer_copy(
diff --git a/extern/include/asio/impl/connect.hpp b/extern/include/asio/impl/connect.hpp
index b2cec7a2..bff1913b 100644
--- a/extern/include/asio/impl/connect.hpp
+++ b/extern/include/asio/impl/connect.hpp
@@ -2,7 +2,7 @@
 // impl/connect.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,14 +15,17 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <algorithm>
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/detail/bind_handler.hpp"
-#include "asio/detail/consuming_buffers.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
+#include "asio/post.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -32,16 +35,100 @@ namespace detail
 {
   struct default_connect_condition
   {
-    template <typename Iterator>
-    Iterator operator()(const asio::error_code&, Iterator next)
+    template <typename Endpoint>
+    bool operator()(const asio::error_code&, const Endpoint&)
     {
-      return next;
+      return true;
     }
   };
+
+  template <typename Protocol, typename Iterator>
+  inline typename Protocol::endpoint deref_connect_result(
+      Iterator iter, asio::error_code& ec)
+  {
+    return ec ? typename Protocol::endpoint() : *iter;
+  }
+
+  template <typename T, typename Iterator>
+  struct legacy_connect_condition_helper : T
+  {
+    typedef char (*fallback_func_type)(...);
+    operator fallback_func_type() const;
+  };
+
+  template <typename R, typename Arg1, typename Arg2, typename Iterator>
+  struct legacy_connect_condition_helper<R (*)(Arg1, Arg2), Iterator>
+  {
+    R operator()(Arg1, Arg2) const;
+    char operator()(...) const;
+  };
+
+  template <typename T, typename Iterator>
+  struct is_legacy_connect_condition
+  {
+    static char asio_connect_condition_check(char);
+    static char (&asio_connect_condition_check(Iterator))[2];
+
+    static const bool value =
+      sizeof(asio_connect_condition_check(
+        (*static_cast<legacy_connect_condition_helper<T, Iterator>*>(0))(
+          *static_cast<const asio::error_code*>(0),
+          *static_cast<const Iterator*>(0)))) != 1;
+  };
+
+  template <typename ConnectCondition, typename Iterator>
+  inline Iterator call_connect_condition(ConnectCondition& connect_condition,
+      const asio::error_code& ec, Iterator next, Iterator end,
+      typename enable_if<is_legacy_connect_condition<
+        ConnectCondition, Iterator>::value>::type* = 0)
+  {
+    if (next != end)
+      return connect_condition(ec, next);
+    return end;
+  }
+
+  template <typename ConnectCondition, typename Iterator>
+  inline Iterator call_connect_condition(ConnectCondition& connect_condition,
+      const asio::error_code& ec, Iterator next, Iterator end,
+      typename enable_if<!is_legacy_connect_condition<
+        ConnectCondition, Iterator>::value>::type* = 0)
+  {
+    for (;next != end; ++next)
+      if (connect_condition(ec, *next))
+        return next;
+    return end;
+  }
+}
+
+template <typename Protocol ASIO_SVC_TPARAM, typename EndpointSequence>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  asio::error_code ec;
+  typename Protocol::endpoint result = connect(s, endpoints, ec);
+  asio::detail::throw_error(ec, "connect");
+  return result;
 }
 
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
+template <typename Protocol ASIO_SVC_TPARAM, typename EndpointSequence>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, asio::error_code& ec,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  return detail::deref_connect_result<Protocol>(
+      connect(s, endpoints.begin(), endpoints.end(),
+        detail::default_connect_condition(), ec), ec);
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s, Iterator begin,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   asio::error_code ec;
   Iterator result = connect(s, begin, ec);
@@ -49,15 +136,17 @@ Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
   return result;
 }
 
-template <typename Protocol, typename SocketService, typename Iterator>
-inline Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, asio::error_code& ec)
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+inline Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    Iterator begin, asio::error_code& ec,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end)
 {
   asio::error_code ec;
@@ -66,17 +155,48 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
   return result;
 }
 
-template <typename Protocol, typename SocketService, typename Iterator>
-inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator>
+inline Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, asio::error_code& ec)
 {
   return connect(s, begin, end, detail::default_connect_condition(), ec);
 }
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  asio::error_code ec;
+  typename Protocol::endpoint result = connect(
+      s, endpoints, connect_condition, ec);
+  asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    asio::error_code& ec,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  return detail::deref_connect_result<Protocol>(
+      connect(s, endpoints.begin(), endpoints.end(),
+        connect_condition, ec), ec);
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+template <typename Protocol ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ConnectCondition connect_condition)
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    Iterator begin, ConnectCondition connect_condition,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   asio::error_code ec;
   Iterator result = connect(s, begin, connect_condition, ec);
@@ -84,18 +204,20 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
   return result;
 }
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+inline Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, ConnectCondition connect_condition,
-    asio::error_code& ec)
+    asio::error_code& ec,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   return connect(s, begin, Iterator(), connect_condition, ec);
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition)
 {
   asio::error_code ec;
@@ -104,9 +226,9 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
   return result;
 }
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+Iterator connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
     asio::error_code& ec)
 {
@@ -114,7 +236,7 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
 
   for (Iterator iter = begin; iter != end; ++iter)
   {
-    iter = connect_condition(ec, iter);
+    iter = (detail::call_connect_condition(connect_condition, ec, iter, end));
     if (iter != end)
     {
       s.close(ec);
@@ -122,6 +244,8 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
       if (!ec)
         return iter;
     }
+    else
+      break;
   }
 
   if (!ec)
@@ -147,8 +271,7 @@ namespace detail
     void check_condition(const asio::error_code& ec,
         Iterator& iter, Iterator& end)
     {
-      if (iter != end)
-        iter = connect_condition_(ec, static_cast<const Iterator&>(iter));
+      iter = detail::call_connect_condition(connect_condition_, ec, iter, end);
     }
 
   private:
@@ -171,26 +294,186 @@ namespace detail
     }
   };
 
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
-  class connect_op : base_from_connect_condition<ConnectCondition>
+  template <typename Protocol ASIO_SVC_TPARAM,
+      typename EndpointSequence, typename ConnectCondition,
+      typename RangeConnectHandler>
+  class range_connect_op : base_from_connect_condition<ConnectCondition>
+  {
+  public:
+    range_connect_op(basic_socket<Protocol ASIO_SVC_TARG>& sock,
+        const EndpointSequence& endpoints,
+        const ConnectCondition& connect_condition,
+        RangeConnectHandler& handler)
+      : base_from_connect_condition<ConnectCondition>(connect_condition),
+        socket_(sock),
+        endpoints_(endpoints),
+        index_(0),
+        start_(0),
+        handler_(ASIO_MOVE_CAST(RangeConnectHandler)(handler))
+    {
+    }
+
+#if defined(ASIO_HAS_MOVE)
+    range_connect_op(const range_connect_op& other)
+      : base_from_connect_condition<ConnectCondition>(other),
+        socket_(other.socket_),
+        endpoints_(other.endpoints_),
+        index_(other.index_),
+        start_(other.start_),
+        handler_(other.handler_)
+    {
+    }
+
+    range_connect_op(range_connect_op&& other)
+      : base_from_connect_condition<ConnectCondition>(other),
+        socket_(other.socket_),
+        endpoints_(other.endpoints_),
+        index_(other.index_),
+        start_(other.start_),
+        handler_(ASIO_MOVE_CAST(RangeConnectHandler)(other.handler_))
+    {
+    }
+#endif // defined(ASIO_HAS_MOVE)
+
+    void operator()(asio::error_code ec, int start = 0)
+    {
+      typename EndpointSequence::const_iterator begin = endpoints_.begin();
+      typename EndpointSequence::const_iterator iter = begin;
+      std::advance(iter, index_);
+      typename EndpointSequence::const_iterator end = endpoints_.end();
+
+      switch (start_ = start)
+      {
+        case 1:
+        for (;;)
+        {
+          this->check_condition(ec, iter, end);
+          index_ = std::distance(begin, iter);
+
+          if (iter != end)
+          {
+            socket_.close(ec);
+            socket_.async_connect(*iter,
+                ASIO_MOVE_CAST(range_connect_op)(*this));
+            return;
+          }
+
+          if (start)
+          {
+            ec = asio::error::not_found;
+            asio::post(socket_.get_executor(),
+                detail::bind_handler(
+                  ASIO_MOVE_CAST(range_connect_op)(*this), ec));
+            return;
+          }
+
+          default:
+
+          if (iter == end)
+            break;
+
+          if (!socket_.is_open())
+          {
+            ec = asio::error::operation_aborted;
+            break;
+          }
+
+          if (!ec)
+            break;
+
+          ++iter;
+          ++index_;
+        }
+
+        handler_(static_cast<const asio::error_code&>(ec),
+            static_cast<const typename Protocol::endpoint&>(
+              ec || iter == end ? typename Protocol::endpoint() : *iter));
+      }
+    }
+
+  //private:
+    basic_socket<Protocol ASIO_SVC_TARG>& socket_;
+    EndpointSequence endpoints_;
+    std::size_t index_;
+    int start_;
+    RangeConnectHandler handler_;
+  };
+
+  template <typename Protocol ASIO_SVC_TPARAM,
+      typename EndpointSequence, typename ConnectCondition,
+      typename RangeConnectHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      range_connect_op<Protocol ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    return asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename Protocol ASIO_SVC_TPARAM,
+      typename EndpointSequence, typename ConnectCondition,
+      typename RangeConnectHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      range_connect_op<Protocol ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Protocol ASIO_SVC_TPARAM,
+      typename EndpointSequence, typename ConnectCondition,
+      typename RangeConnectHandler>
+  inline bool asio_handler_is_continuation(
+      range_connect_op<Protocol ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    return asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol
+      ASIO_SVC_TPARAM, typename EndpointSequence,
+      typename ConnectCondition, typename RangeConnectHandler>
+  inline void asio_handler_invoke(Function& function,
+      range_connect_op<Protocol ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol
+      ASIO_SVC_TPARAM, typename EndpointSequence,
+      typename ConnectCondition, typename RangeConnectHandler>
+  inline void asio_handler_invoke(const Function& function,
+      range_connect_op<Protocol ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+      typename ConnectCondition, typename IteratorConnectHandler>
+  class iterator_connect_op : base_from_connect_condition<ConnectCondition>
   {
   public:
-    connect_op(basic_socket<Protocol, SocketService>& sock,
+    iterator_connect_op(basic_socket<Protocol ASIO_SVC_TARG>& sock,
         const Iterator& begin, const Iterator& end,
         const ConnectCondition& connect_condition,
-        ComposedConnectHandler& handler)
+        IteratorConnectHandler& handler)
       : base_from_connect_condition<ConnectCondition>(connect_condition),
         socket_(sock),
         iter_(begin),
         end_(end),
         start_(0),
-        handler_(ASIO_MOVE_CAST(ComposedConnectHandler)(handler))
+        handler_(ASIO_MOVE_CAST(IteratorConnectHandler)(handler))
     {
     }
 
 #if defined(ASIO_HAS_MOVE)
-    connect_op(const connect_op& other)
+    iterator_connect_op(const iterator_connect_op& other)
       : base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
@@ -200,13 +483,13 @@ namespace detail
     {
     }
 
-    connect_op(connect_op&& other)
+    iterator_connect_op(iterator_connect_op&& other)
       : base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
         start_(other.start_),
-        handler_(ASIO_MOVE_CAST(ComposedConnectHandler)(other.handler_))
+        handler_(ASIO_MOVE_CAST(IteratorConnectHandler)(other.handler_))
     {
     }
 #endif // defined(ASIO_HAS_MOVE)
@@ -224,14 +507,16 @@ namespace detail
           {
             socket_.close(ec);
             socket_.async_connect(*iter_,
-                ASIO_MOVE_CAST(connect_op)(*this));
+                ASIO_MOVE_CAST(iterator_connect_op)(*this));
             return;
           }
 
           if (start)
           {
             ec = asio::error::not_found;
-            socket_.get_io_service().post(detail::bind_handler(*this, ec));
+            asio::post(socket_.get_executor(),
+                detail::bind_handler(
+                  ASIO_MOVE_CAST(iterator_connect_op)(*this), ec));
             return;
           }
 
@@ -258,164 +543,311 @@ namespace detail
     }
 
   //private:
-    basic_socket<Protocol, SocketService>& socket_;
+    basic_socket<Protocol ASIO_SVC_TARG>& socket_;
     Iterator iter_;
     Iterator end_;
     int start_;
-    ComposedConnectHandler handler_;
+    IteratorConnectHandler handler_;
   };
 
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+      typename ConnectCondition, typename IteratorConnectHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      connect_op<Protocol, SocketService, Iterator,
-        ConnectCondition, ComposedConnectHandler>* this_handler)
+      iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+      typename ConnectCondition, typename IteratorConnectHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      connect_op<Protocol, SocketService, Iterator,
-        ConnectCondition, ComposedConnectHandler>* this_handler)
+      iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+      typename ConnectCondition, typename IteratorConnectHandler>
   inline bool asio_handler_is_continuation(
-      connect_op<Protocol, SocketService, Iterator,
-        ConnectCondition, ComposedConnectHandler>* this_handler)
+      iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     return asio_handler_cont_helpers::is_continuation(
         this_handler->handler_);
   }
 
-  template <typename Function, typename Protocol,
-      typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Function, typename Protocol
+      ASIO_SVC_TPARAM, typename Iterator,
+      typename ConnectCondition, typename IteratorConnectHandler>
   inline void asio_handler_invoke(Function& function,
-      connect_op<Protocol, SocketService, Iterator,
-        ConnectCondition, ComposedConnectHandler>* this_handler)
+      iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename Protocol,
-      typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Function, typename Protocol
+      ASIO_SVC_TPARAM, typename Iterator,
+      typename ConnectCondition, typename IteratorConnectHandler>
   inline void asio_handler_invoke(const Function& function,
-      connect_op<Protocol, SocketService, Iterator,
-        ConnectCondition, ComposedConnectHandler>* this_handler)
+      iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-inline ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition,
+    typename RangeConnectHandler, typename Allocator>
+struct associated_allocator<
+    detail::range_connect_op<Protocol ASIO_SVC_TARG,
+      EndpointSequence, ConnectCondition, RangeConnectHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<
+      RangeConnectHandler, Allocator>::type type;
+
+  static type get(
+      const detail::range_connect_op<Protocol ASIO_SVC_TARG,
+        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<RangeConnectHandler,
+        Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition,
+    typename RangeConnectHandler, typename Executor>
+struct associated_executor<
+    detail::range_connect_op<Protocol ASIO_SVC_TARG,
+      EndpointSequence, ConnectCondition, RangeConnectHandler>,
+    Executor>
+{
+  typedef typename associated_executor<
+      RangeConnectHandler, Executor>::type type;
+
+  static type get(
+      const detail::range_connect_op<Protocol ASIO_SVC_TARG,
+        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<RangeConnectHandler,
+        Executor>::get(h.handler_, ex);
+  }
+};
+
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Iterator, typename ConnectCondition,
+    typename IteratorConnectHandler, typename Allocator>
+struct associated_allocator<
+    detail::iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
+      ConnectCondition, IteratorConnectHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<
+      IteratorConnectHandler, Allocator>::type type;
+
+  static type get(
+      const detail::iterator_connect_op<Protocol ASIO_SVC_TARG,
+        Iterator, ConnectCondition, IteratorConnectHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<IteratorConnectHandler,
+        Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Iterator, typename ConnectCondition,
+    typename IteratorConnectHandler, typename Executor>
+struct associated_executor<
+    detail::iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
+      ConnectCondition, IteratorConnectHandler>,
+    Executor>
+{
+  typedef typename associated_executor<
+      IteratorConnectHandler, Executor>::type type;
+
+  static type get(
+      const detail::iterator_connect_op<Protocol ASIO_SVC_TARG,
+        Iterator, ConnectCondition, IteratorConnectHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<IteratorConnectHandler,
+        Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename RangeConnectHandler>
+inline ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+    void (asio::error_code, typename Protocol::endpoint))
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints,
+    ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a RangeConnectHandler.
+  ASIO_RANGE_CONNECT_HANDLER_CHECK(
+      RangeConnectHandler, handler, typename Protocol::endpoint) type_check;
+
+  async_completion<RangeConnectHandler,
+    void (asio::error_code, typename Protocol::endpoint)>
+      init(handler);
+
+  detail::range_connect_op<Protocol ASIO_SVC_TARG, EndpointSequence,
+    detail::default_connect_condition,
+      ASIO_HANDLER_TYPE(RangeConnectHandler,
+        void (asio::error_code, typename Protocol::endpoint))>(s,
+          endpoints, detail::default_connect_condition(),
+            init.completion_handler)(asio::error_code(), 1);
+
+  return init.result.get();
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Iterator, typename IteratorConnectHandler>
+inline ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    Iterator begin, ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   // If you get an error on the following line it means that your handler does
-  // not meet the documented type requirements for a ComposedConnectHandler.
-  ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (asio::error_code, Iterator)> init(
-      ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (asio::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
     detail::default_connect_condition, ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (asio::error_code, Iterator))>(s,
-        begin, Iterator(), detail::default_connect_condition(), init.handler)(
-          asio::error_code(), 1);
+      IteratorConnectHandler, void (asio::error_code, Iterator))>(s,
+        begin, Iterator(), detail::default_connect_condition(),
+          init.completion_handler)(asio::error_code(), 1);
 
   return init.result.get();
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-inline ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol ASIO_SVC_TPARAM,
+    typename Iterator, typename IteratorConnectHandler>
+inline ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end,
-    ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+    ASIO_MOVE_ARG(IteratorConnectHandler) 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.
-  ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (asio::error_code, Iterator)> init(
-      ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (asio::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
     detail::default_connect_condition, ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (asio::error_code, Iterator))>(s,
-        begin, end, detail::default_connect_condition(), init.handler)(
+      IteratorConnectHandler, void (asio::error_code, Iterator))>(s,
+        begin, end, detail::default_connect_condition(),
+          init.completion_handler)(asio::error_code(), 1);
+
+  return init.result.get();
+}
+
+template <typename Protocol ASIO_SVC_TPARAM, typename EndpointSequence,
+    typename ConnectCondition, typename RangeConnectHandler>
+inline ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+    void (asio::error_code, typename Protocol::endpoint))
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a RangeConnectHandler.
+  ASIO_RANGE_CONNECT_HANDLER_CHECK(
+      RangeConnectHandler, handler, typename Protocol::endpoint) type_check;
+
+  async_completion<RangeConnectHandler,
+    void (asio::error_code, typename Protocol::endpoint)>
+      init(handler);
+
+  detail::range_connect_op<Protocol ASIO_SVC_TARG, EndpointSequence,
+    ConnectCondition, ASIO_HANDLER_TYPE(RangeConnectHandler,
+      void (asio::error_code, typename Protocol::endpoint))>(s,
+        endpoints, connect_condition, init.completion_handler)(
           asio::error_code(), 1);
 
   return init.result.get();
 }
 
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-inline ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+#if !defined(ASIO_NO_DEPRECATED)
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+    typename ConnectCondition, typename IteratorConnectHandler>
+inline ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, ConnectCondition connect_condition,
-    ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+    ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   // If you get an error on the following line it means that your handler does
-  // not meet the documented type requirements for a ComposedConnectHandler.
-  ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (asio::error_code, Iterator)> init(
-      ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (asio::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
     ConnectCondition, ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (asio::error_code, Iterator))>(s,
-        begin, Iterator(), connect_condition, init.handler)(
+      IteratorConnectHandler, void (asio::error_code, Iterator))>(s,
+        begin, Iterator(), connect_condition, init.completion_handler)(
           asio::error_code(), 1);
 
   return init.result.get();
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-inline ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol ASIO_SVC_TPARAM, typename Iterator,
+    typename ConnectCondition, typename IteratorConnectHandler>
+inline ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (asio::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
-    ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+    ASIO_MOVE_ARG(IteratorConnectHandler) 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.
-  ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (asio::error_code, Iterator)> init(
-      ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (asio::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol ASIO_SVC_TARG, Iterator,
     ConnectCondition, ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (asio::error_code, Iterator))>(s,
-        begin, end, connect_condition, init.handler)(
+      IteratorConnectHandler, void (asio::error_code, Iterator))>(s,
+        begin, end, connect_condition, init.completion_handler)(
           asio::error_code(), 1);
 
   return init.result.get();
diff --git a/extern/include/asio/impl/defer.hpp b/extern/include/asio/impl/defer.hpp
new file mode 100644
index 00000000..a27df0f1
--- /dev/null
+++ b/extern/include/asio/impl/defer.hpp
@@ -0,0 +1,77 @@
+//
+// impl/defer.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_DEFER_HPP
+#define ASIO_IMPL_DEFER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/detail/work_dispatcher.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
+    ASIO_MOVE_ARG(CompletionToken) token)
+{
+  typedef ASIO_HANDLER_TYPE(CompletionToken, void()) handler;
+
+  async_completion<CompletionToken, void()> init(token);
+
+  typename associated_executor<handler>::type ex(
+      (get_associated_executor)(init.completion_handler));
+
+  typename associated_allocator<handler>::type alloc(
+      (get_associated_allocator)(init.completion_handler));
+
+  ex.defer(ASIO_MOVE_CAST(handler)(init.completion_handler), alloc);
+
+  return init.result.get();
+}
+
+template <typename Executor, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
+    const Executor& ex, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_executor<Executor>::value>::type*)
+{
+  typedef ASIO_HANDLER_TYPE(CompletionToken, void()) handler;
+
+  async_completion<CompletionToken, void()> init(token);
+
+  typename associated_allocator<handler>::type alloc(
+      (get_associated_allocator)(init.completion_handler));
+
+  ex.defer(detail::work_dispatcher<handler>(init.completion_handler), alloc);
+
+  return init.result.get();
+}
+
+template <typename ExecutionContext, typename CompletionToken>
+inline ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) defer(
+    ExecutionContext& ctx, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type*)
+{
+  return (defer)(ctx.get_executor(),
+      ASIO_MOVE_CAST(CompletionToken)(token));
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_DEFER_HPP
diff --git a/extern/include/asio/impl/dispatch.hpp b/extern/include/asio/impl/dispatch.hpp
new file mode 100644
index 00000000..4e11c6b2
--- /dev/null
+++ b/extern/include/asio/impl/dispatch.hpp
@@ -0,0 +1,78 @@
+//
+// impl/dispatch.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_DISPATCH_HPP
+#define ASIO_IMPL_DISPATCH_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/detail/work_dispatcher.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) dispatch(
+    ASIO_MOVE_ARG(CompletionToken) token)
+{
+  typedef ASIO_HANDLER_TYPE(CompletionToken, void()) handler;
+
+  async_completion<CompletionToken, void()> init(token);
+
+  typename associated_executor<handler>::type ex(
+      (get_associated_executor)(init.completion_handler));
+
+  typename associated_allocator<handler>::type alloc(
+      (get_associated_allocator)(init.completion_handler));
+
+  ex.dispatch(ASIO_MOVE_CAST(handler)(init.completion_handler), alloc);
+
+  return init.result.get();
+}
+
+template <typename Executor, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) dispatch(
+    const Executor& ex, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_executor<Executor>::value>::type*)
+{
+  typedef ASIO_HANDLER_TYPE(CompletionToken, void()) handler;
+
+  async_completion<CompletionToken, void()> init(token);
+
+  typename associated_allocator<handler>::type alloc(
+      (get_associated_allocator)(init.completion_handler));
+
+  ex.dispatch(detail::work_dispatcher<handler>(
+        init.completion_handler), alloc);
+
+  return init.result.get();
+}
+
+template <typename ExecutionContext, typename CompletionToken>
+inline ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) dispatch(
+    ExecutionContext& ctx, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type*)
+{
+  return (dispatch)(ctx.get_executor(),
+      ASIO_MOVE_CAST(CompletionToken)(token));
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_DISPATCH_HPP
diff --git a/extern/include/asio/impl/error.ipp b/extern/include/asio/impl/error.ipp
index fc59d0ba..6b1f33a4 100644
--- a/extern/include/asio/impl/error.ipp
+++ b/extern/include/asio/impl/error.ipp
@@ -2,7 +2,7 @@
 // impl/error.ipp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/impl/error_code.ipp b/extern/include/asio/impl/error_code.ipp
index ccb70dd9..0c8a8278 100644
--- a/extern/include/asio/impl/error_code.ipp
+++ b/extern/include/asio/impl/error_code.ipp
@@ -2,7 +2,7 @@
 // impl/error_code.ipp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -44,28 +44,14 @@ public:
 
   std::string message(int value) const
   {
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    char* msg = 0;
-    DWORD length = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
-        | FORMAT_MESSAGE_FROM_SYSTEM
-        | FORMAT_MESSAGE_IGNORE_INSERTS, 0, value,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&msg, 0, 0);
-    detail::local_free_on_block_exit local_free_obj(msg);
-    if (length && msg[length - 1] == '\n')
-      msg[--length] = '\0';
-    if (length && msg[length - 1] == '\r')
-      msg[--length] = '\0';
-    if (length)
-      return msg;
-    else
-      return "asio.system error";
-#elif defined(ASIO_WINDOWS_RUNTIME)
+#if defined(ASIO_WINDOWS_RUNTIME) || defined(ASIO_WINDOWS_APP)
     std::wstring wmsg(128, wchar_t());
     for (;;)
     {
       DWORD wlength = ::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM
           | FORMAT_MESSAGE_IGNORE_INSERTS, 0, value,
-          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), &wmsg[0], wmsg.size(), 0);
+          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+          &wmsg[0], static_cast<DWORD>(wmsg.size()), 0);
       if (wlength == 0 && ::GetLastError() == ERROR_INSUFFICIENT_BUFFER)
       {
         wmsg.resize(wmsg.size() + wmsg.size() / 2);
@@ -89,7 +75,22 @@ public:
       else
         return "asio.system error";
     }
-#else // defined(ASIO_WINDOWS)
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+    char* msg = 0;
+    DWORD length = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
+        | FORMAT_MESSAGE_FROM_SYSTEM
+        | FORMAT_MESSAGE_IGNORE_INSERTS, 0, value,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&msg, 0, 0);
+    detail::local_free_on_block_exit local_free_obj(msg);
+    if (length && msg[length - 1] == '\n')
+      msg[--length] = '\0';
+    if (length && msg[length - 1] == '\r')
+      msg[--length] = '\0';
+    if (length)
+      return msg;
+    else
+      return "asio.system error";
+#else // defined(ASIO_WINDOWS_DESKTOP) || defined(__CYGWIN__)
 #if !defined(__sun)
     if (value == ECANCELED)
       return "Operation aborted.";
@@ -97,20 +98,97 @@ public:
 #if defined(__sun) || defined(__QNX__) || defined(__SYMBIAN32__)
     using namespace std;
     return strerror(value);
-#elif defined(__MACH__) && defined(__APPLE__) \
-  || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) \
-  || defined(_AIX) || defined(__hpux) || defined(__osf__) \
-  || defined(__ANDROID__)
-    char buf[256] = "";
-    using namespace std;
-    strerror_r(value, buf, sizeof(buf));
-    return buf;
 #else
     char buf[256] = "";
-    return strerror_r(value, buf, sizeof(buf));
+    using namespace std;
+    return strerror_result(strerror_r(value, buf, sizeof(buf)), buf);
 #endif
-#endif // defined(ASIO_WINDOWS)
+#endif // defined(ASIO_WINDOWS_DESKTOP) || defined(__CYGWIN__)
   }
+
+#if defined(ASIO_HAS_STD_ERROR_CODE)
+  std::error_condition default_error_condition(
+      int ev) const ASIO_ERROR_CATEGORY_NOEXCEPT
+  {
+    switch (ev)
+    {
+    case access_denied:
+      return std::errc::permission_denied;
+    case address_family_not_supported:
+      return std::errc::address_family_not_supported;
+    case address_in_use:
+      return std::errc::address_in_use;
+    case already_connected:
+      return std::errc::already_connected;
+    case already_started:
+      return std::errc::connection_already_in_progress;
+    case broken_pipe:
+      return std::errc::broken_pipe;
+    case connection_aborted:
+      return std::errc::connection_aborted;
+    case connection_refused:
+      return std::errc::connection_refused;
+    case connection_reset:
+      return std::errc::connection_reset;
+    case bad_descriptor:
+      return std::errc::bad_file_descriptor;
+    case fault:
+      return std::errc::bad_address;
+    case host_unreachable:
+      return std::errc::host_unreachable;
+    case in_progress:
+      return std::errc::operation_in_progress;
+    case interrupted:
+      return std::errc::interrupted;
+    case invalid_argument:
+      return std::errc::invalid_argument;
+    case message_size:
+      return std::errc::message_size;
+    case name_too_long:
+      return std::errc::filename_too_long;
+    case network_down:
+      return std::errc::network_down;
+    case network_reset:
+      return std::errc::network_reset;
+    case network_unreachable:
+      return std::errc::network_unreachable;
+    case no_descriptors:
+      return std::errc::too_many_files_open;
+    case no_buffer_space:
+      return std::errc::no_buffer_space;
+    case no_memory:
+      return std::errc::not_enough_memory;
+    case no_permission:
+      return std::errc::operation_not_permitted;
+    case no_protocol_option:
+      return std::errc::no_protocol_option;
+    case no_such_device:
+      return std::errc::no_such_device;
+    case not_connected:
+      return std::errc::not_connected;
+    case not_socket:
+      return std::errc::not_a_socket;
+    case operation_aborted:
+      return std::errc::operation_canceled;
+    case operation_not_supported:
+      return std::errc::operation_not_supported;
+    case shut_down:
+      return std::make_error_condition(ev, *this);
+    case timed_out:
+      return std::errc::timed_out;
+    case try_again:
+      return std::errc::resource_unavailable_try_again;
+    case would_block:
+      return std::errc::operation_would_block;
+    default:
+      return std::make_error_condition(ev, *this);
+  }
+#endif // defined(ASIO_HAS_STD_ERROR_CODE)
+
+private:
+  // Helper function to adapt the result from glibc's variant of strerror_r.
+  static const char* strerror_result(int, const char* s) { return s; }
+  static const char* strerror_result(const char* s, const char*) { return s; }
 };
 
 } // namespace detail
diff --git a/extern/include/asio/impl/execution_context.hpp b/extern/include/asio/impl/execution_context.hpp
new file mode 100644
index 00000000..3d1e457e
--- /dev/null
+++ b/extern/include/asio/impl/execution_context.hpp
@@ -0,0 +1,107 @@
+//
+// impl/execution_context.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_EXECUTION_CONTEXT_HPP
+#define ASIO_IMPL_EXECUTION_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/scoped_ptr.hpp"
+#include "asio/detail/service_registry.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+template <typename Service>
+inline Service& use_service(execution_context& e)
+{
+  // Check that Service meets the necessary type requirements.
+  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
+
+  return e.service_registry_->template use_service<Service>();
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+# if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Service, typename... Args>
+Service& make_service(execution_context& e, ASIO_MOVE_ARG(Args)... args)
+{
+  detail::scoped_ptr<Service> svc(
+      new Service(e, ASIO_MOVE_CAST(Args)(args)...));
+  e.service_registry_->template add_service<Service>(svc.get());
+  Service& result = *svc;
+  svc.release();
+  return result;
+}
+
+# else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Service>
+Service& make_service(execution_context& e)
+{
+  detail::scoped_ptr<Service> svc(new Service(e));
+  e.service_registry_->template add_service<Service>(svc.get());
+  Service& result = *svc;
+  svc.release();
+  return result;
+}
+
+#define ASIO_PRIVATE_MAKE_SERVICE_DEF(n) \
+  template <typename Service, ASIO_VARIADIC_TPARAMS(n)> \
+  Service& make_service(execution_context& e, \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    detail::scoped_ptr<Service> svc( \
+        new Service(e, ASIO_VARIADIC_MOVE_ARGS(n))); \
+    e.service_registry_->template add_service<Service>(svc.get()); \
+    Service& result = *svc; \
+    svc.release(); \
+    return result; \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_MAKE_SERVICE_DEF)
+#undef ASIO_PRIVATE_MAKE_SERVICE_DEF
+
+# endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename Service>
+inline void add_service(execution_context& e, Service* svc)
+{
+  // Check that Service meets the necessary type requirements.
+  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
+
+  e.service_registry_->template add_service<Service>(svc);
+}
+
+template <typename Service>
+inline bool has_service(execution_context& e)
+{
+  // Check that Service meets the necessary type requirements.
+  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
+
+  return e.service_registry_->template has_service<Service>();
+}
+
+inline execution_context& execution_context::service::context()
+{
+  return owner_;
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_EXECUTION_CONTEXT_HPP
diff --git a/extern/include/asio/impl/execution_context.ipp b/extern/include/asio/impl/execution_context.ipp
new file mode 100644
index 00000000..c2b3b21a
--- /dev/null
+++ b/extern/include/asio/impl/execution_context.ipp
@@ -0,0 +1,82 @@
+//
+// impl/execution_context.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_EXECUTION_CONTEXT_IPP
+#define ASIO_IMPL_EXECUTION_CONTEXT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/detail/service_registry.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+execution_context::execution_context()
+  : service_registry_(new asio::detail::service_registry(*this))
+{
+}
+
+execution_context::~execution_context()
+{
+  shutdown();
+  destroy();
+  delete service_registry_;
+}
+
+void execution_context::shutdown()
+{
+  service_registry_->shutdown_services();
+}
+
+void execution_context::destroy()
+{
+  service_registry_->destroy_services();
+}
+
+void execution_context::notify_fork(
+    asio::execution_context::fork_event event)
+{
+  service_registry_->notify_fork(event);
+}
+
+execution_context::service::service(execution_context& owner)
+  : owner_(owner),
+    next_(0)
+{
+}
+
+execution_context::service::~service()
+{
+}
+
+void execution_context::service::notify_fork(execution_context::fork_event)
+{
+}
+
+service_already_exists::service_already_exists()
+  : std::logic_error("Service already exists.")
+{
+}
+
+invalid_service_owner::invalid_service_owner()
+  : std::logic_error("Invalid service owner.")
+{
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_EXECUTION_CONTEXT_IPP
diff --git a/extern/include/asio/impl/executor.hpp b/extern/include/asio/impl/executor.hpp
new file mode 100644
index 00000000..0fcf5f54
--- /dev/null
+++ b/extern/include/asio/impl/executor.hpp
@@ -0,0 +1,386 @@
+//
+// impl/executor.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_EXECUTOR_HPP
+#define ASIO_IMPL_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/atomic_count.hpp"
+#include "asio/detail/executor_op.hpp"
+#include "asio/detail/global.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/recycling_allocator.hpp"
+#include "asio/executor.hpp"
+#include "asio/system_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+#if defined(ASIO_HAS_MOVE)
+
+// Lightweight, move-only function object wrapper.
+class executor::function
+{
+public:
+  template <typename F, typename Alloc>
+  explicit function(F f, const Alloc& a)
+  {
+    // Allocate and construct an operation to wrap the function.
+    typedef detail::executor_op<F, Alloc> op;
+    typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+    op_ = new (p.v) op(ASIO_MOVE_CAST(F)(f), a);
+    p.v = 0;
+  }
+
+  function(function&& other)
+    : op_(other.op_)
+  {
+    other.op_ = 0;
+  }
+
+  ~function()
+  {
+    if (op_)
+      op_->destroy();
+  }
+
+  void operator()()
+  {
+    if (op_)
+    {
+      detail::scheduler_operation* op = op_;
+      op_ = 0;
+      op->complete(this, asio::error_code(), 0);
+    }
+  }
+
+private:
+  detail::scheduler_operation* op_;
+};
+
+#else // defined(ASIO_HAS_MOVE)
+
+// Not so lightweight, copyable function object wrapper.
+class executor::function
+{
+public:
+  template <typename F, typename Alloc>
+  explicit function(const F& f, const Alloc&)
+    : impl_(new impl<F>(f))
+  {
+  }
+
+  void operator()()
+  {
+    impl_->invoke_(impl_.get());
+  }
+
+private:
+  // Base class for polymorphic function implementations.
+  struct impl_base
+  {
+    void (*invoke_)(impl_base*);
+  };
+
+  // Polymorphic function implementation.
+  template <typename F>
+  struct impl : impl_base
+  {
+    impl(const F& f)
+      : function_(f)
+    {
+      invoke_ = &function::invoke<F>;
+    }
+
+    F function_;
+  };
+
+  // Helper to invoke a function.
+  template <typename F>
+  static void invoke(impl_base* i)
+  {
+    static_cast<impl<F>*>(i)->function_();
+  }
+
+  detail::shared_ptr<impl_base> impl_;
+};
+
+#endif // defined(ASIO_HAS_MOVE)
+
+// Default polymorphic allocator implementation.
+template <typename Executor, typename Allocator>
+class executor::impl
+  : public executor::impl_base
+{
+public:
+  typedef ASIO_REBIND_ALLOC(Allocator, impl) allocator_type;
+
+  static impl_base* create(const Executor& e, Allocator a = Allocator())
+  {
+    raw_mem mem(a);
+    impl* p = new (mem.ptr_) impl(e, a);
+    mem.ptr_ = 0;
+    return p;
+  }
+
+  impl(const Executor& e, const Allocator& a) ASIO_NOEXCEPT
+    : impl_base(false),
+      ref_count_(1),
+      executor_(e),
+      allocator_(a)
+  {
+  }
+
+  impl_base* clone() const ASIO_NOEXCEPT
+  {
+    ++ref_count_;
+    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
+  }
+
+  void destroy() ASIO_NOEXCEPT
+  {
+    if (--ref_count_ == 0)
+    {
+      allocator_type alloc(allocator_);
+      impl* p = this;
+      p->~impl();
+      alloc.deallocate(p, 1);
+    }
+  }
+
+  void on_work_started() ASIO_NOEXCEPT
+  {
+    executor_.on_work_started();
+  }
+
+  void on_work_finished() ASIO_NOEXCEPT
+  {
+    executor_.on_work_finished();
+  }
+
+  execution_context& context() ASIO_NOEXCEPT
+  {
+    return executor_.context();
+  }
+
+  void dispatch(ASIO_MOVE_ARG(function) f)
+  {
+    executor_.dispatch(ASIO_MOVE_CAST(function)(f), allocator_);
+  }
+
+  void post(ASIO_MOVE_ARG(function) f)
+  {
+    executor_.post(ASIO_MOVE_CAST(function)(f), allocator_);
+  }
+
+  void defer(ASIO_MOVE_ARG(function) f)
+  {
+    executor_.defer(ASIO_MOVE_CAST(function)(f), allocator_);
+  }
+
+  type_id_result_type target_type() const ASIO_NOEXCEPT
+  {
+    return type_id<Executor>();
+  }
+
+  void* target() ASIO_NOEXCEPT
+  {
+    return &executor_;
+  }
+
+  const void* target() const ASIO_NOEXCEPT
+  {
+    return &executor_;
+  }
+
+  bool equals(const impl_base* e) const ASIO_NOEXCEPT
+  {
+    if (this == e)
+      return true;
+    if (target_type() != e->target_type())
+      return false;
+    return executor_ == *static_cast<const Executor*>(e->target());
+  }
+
+private:
+  mutable detail::atomic_count ref_count_;
+  Executor executor_;
+  Allocator allocator_;
+
+  struct raw_mem
+  {
+    allocator_type allocator_;
+    impl* ptr_;
+
+    explicit raw_mem(const Allocator& a)
+      : allocator_(a),
+        ptr_(allocator_.allocate(1))
+    {
+    }
+
+    ~raw_mem()
+    {
+      if (ptr_)
+        allocator_.deallocate(ptr_, 1);
+    }
+
+  private:
+    // Disallow copying and assignment.
+    raw_mem(const raw_mem&);
+    raw_mem operator=(const raw_mem&);
+  };
+};
+
+// Polymorphic allocator specialisation for system_executor.
+template <typename Allocator>
+class executor::impl<system_executor, Allocator>
+  : public executor::impl_base
+{
+public:
+  static impl_base* create(const system_executor&,
+      const Allocator& = Allocator())
+  {
+    return &detail::global<impl<system_executor, std::allocator<void> > >();
+  }
+
+  impl()
+    : impl_base(true)
+  {
+  }
+
+  impl_base* clone() const ASIO_NOEXCEPT
+  {
+    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
+  }
+
+  void destroy() ASIO_NOEXCEPT
+  {
+  }
+
+  void on_work_started() ASIO_NOEXCEPT
+  {
+    executor_.on_work_started();
+  }
+
+  void on_work_finished() ASIO_NOEXCEPT
+  {
+    executor_.on_work_finished();
+  }
+
+  execution_context& context() ASIO_NOEXCEPT
+  {
+    return executor_.context();
+  }
+
+  void dispatch(ASIO_MOVE_ARG(function) f)
+  {
+    executor_.dispatch(ASIO_MOVE_CAST(function)(f), allocator_);
+  }
+
+  void post(ASIO_MOVE_ARG(function) f)
+  {
+    executor_.post(ASIO_MOVE_CAST(function)(f), allocator_);
+  }
+
+  void defer(ASIO_MOVE_ARG(function) f)
+  {
+    executor_.defer(ASIO_MOVE_CAST(function)(f), allocator_);
+  }
+
+  type_id_result_type target_type() const ASIO_NOEXCEPT
+  {
+    return type_id<system_executor>();
+  }
+
+  void* target() ASIO_NOEXCEPT
+  {
+    return &executor_;
+  }
+
+  const void* target() const ASIO_NOEXCEPT
+  {
+    return &executor_;
+  }
+
+  bool equals(const impl_base* e) const ASIO_NOEXCEPT
+  {
+    return this == e;
+  }
+
+private:
+  system_executor executor_;
+  Allocator allocator_;
+};
+
+template <typename Executor>
+executor::executor(Executor e)
+  : impl_(impl<Executor, std::allocator<void> >::create(e))
+{
+}
+
+template <typename Executor, typename Allocator>
+executor::executor(allocator_arg_t, const Allocator& a, Executor e)
+  : impl_(impl<Executor, Allocator>::create(e, a))
+{
+}
+
+template <typename Function, typename Allocator>
+void executor::dispatch(ASIO_MOVE_ARG(Function) f,
+    const Allocator& a) const
+{
+  impl_base* i = get_impl();
+  if (i->fast_dispatch_)
+    system_executor().dispatch(ASIO_MOVE_CAST(Function)(f), a);
+  else
+    i->dispatch(function(ASIO_MOVE_CAST(Function)(f), a));
+}
+
+template <typename Function, typename Allocator>
+void executor::post(ASIO_MOVE_ARG(Function) f,
+    const Allocator& a) const
+{
+  get_impl()->post(function(ASIO_MOVE_CAST(Function)(f), a));
+}
+
+template <typename Function, typename Allocator>
+void executor::defer(ASIO_MOVE_ARG(Function) f,
+    const Allocator& a) const
+{
+  get_impl()->defer(function(ASIO_MOVE_CAST(Function)(f), a));
+}
+
+template <typename Executor>
+Executor* executor::target() ASIO_NOEXCEPT
+{
+  return impl_ && impl_->target_type() == type_id<Executor>()
+    ? static_cast<Executor*>(impl_->target()) : 0;
+}
+
+template <typename Executor>
+const Executor* executor::target() const ASIO_NOEXCEPT
+{
+  return impl_ && impl_->target_type() == type_id<Executor>()
+    ? static_cast<Executor*>(impl_->target()) : 0;
+}
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_EXECUTOR_HPP
diff --git a/extern/include/asio/impl/executor.ipp b/extern/include/asio/impl/executor.ipp
new file mode 100644
index 00000000..4bd0dc5c
--- /dev/null
+++ b/extern/include/asio/impl/executor.ipp
@@ -0,0 +1,38 @@
+//
+// impl/executor.ipp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_EXECUTOR_IPP
+#define ASIO_IMPL_EXECUTOR_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+bad_executor::bad_executor() ASIO_NOEXCEPT
+{
+}
+
+const char* bad_executor::what() const ASIO_NOEXCEPT_OR_NOTHROW
+{
+  return "bad executor";
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_EXECUTOR_IPP
diff --git a/extern/include/asio/impl/handler_alloc_hook.ipp b/extern/include/asio/impl/handler_alloc_hook.ipp
index 3cff7928..909ddace 100644
--- a/extern/include/asio/impl/handler_alloc_hook.ipp
+++ b/extern/include/asio/impl/handler_alloc_hook.ipp
@@ -2,7 +2,7 @@
 // impl/handler_alloc_hook.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,37 +16,19 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/call_stack.hpp"
+#include "asio/detail/thread_context.hpp"
+#include "asio/detail/thread_info_base.hpp"
 #include "asio/handler_alloc_hook.hpp"
 
-#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-# if defined(ASIO_HAS_IOCP)
-#  include "asio/detail/win_iocp_thread_info.hpp"
-# else // defined(ASIO_HAS_IOCP)
-#  include "asio/detail/task_io_service_thread_info.hpp"
-# endif // defined(ASIO_HAS_IOCP)
-#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 
-#if defined(ASIO_HAS_IOCP)
-namespace detail { class win_iocp_io_service; }
-#endif // defined(ASIO_HAS_IOCP)
-
 void* asio_handler_allocate(std::size_t size, ...)
 {
 #if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-# if defined(ASIO_HAS_IOCP)
-  typedef detail::win_iocp_io_service io_service_impl;
-  typedef detail::win_iocp_thread_info thread_info;
-# else // defined(ASIO_HAS_IOCP)
-  typedef detail::task_io_service io_service_impl;
-  typedef detail::task_io_service_thread_info thread_info;
-# endif // defined(ASIO_HAS_IOCP)
-  typedef detail::call_stack<io_service_impl, thread_info> call_stack;
-  return thread_info::allocate(call_stack::top(), size);
+  return detail::thread_info_base::allocate(
+      detail::thread_context::thread_call_stack::top(), size);
 #else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   return ::operator new(size);
 #endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
@@ -55,15 +37,8 @@ void* asio_handler_allocate(std::size_t size, ...)
 void asio_handler_deallocate(void* pointer, std::size_t size, ...)
 {
 #if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-# if defined(ASIO_HAS_IOCP)
-  typedef detail::win_iocp_io_service io_service_impl;
-  typedef detail::win_iocp_thread_info thread_info;
-# else // defined(ASIO_HAS_IOCP)
-  typedef detail::task_io_service io_service_impl;
-  typedef detail::task_io_service_thread_info thread_info;
-# endif // defined(ASIO_HAS_IOCP)
-  typedef detail::call_stack<io_service_impl, thread_info> call_stack;
-  thread_info::deallocate(call_stack::top(), pointer, size);
+  detail::thread_info_base::deallocate(
+      detail::thread_context::thread_call_stack::top(), pointer, size);
 #else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   (void)size;
   ::operator delete(pointer);
diff --git a/extern/include/asio/impl/io_context.hpp b/extern/include/asio/impl/io_context.hpp
new file mode 100644
index 00000000..eaf580da
--- /dev/null
+++ b/extern/include/asio/impl/io_context.hpp
@@ -0,0 +1,343 @@
+//
+// impl/io_context.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_IO_CONTEXT_HPP
+#define ASIO_IMPL_IO_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/completion_handler.hpp"
+#include "asio/detail/executor_op.hpp"
+#include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/recycling_allocator.hpp"
+#include "asio/detail/service_registry.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/type_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+template <typename Service>
+inline Service& use_service(io_context& ioc)
+{
+  // Check that Service meets the necessary type requirements.
+  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
+  (void)static_cast<const execution_context::id*>(&Service::id);
+
+  return ioc.service_registry_->template use_service<Service>(ioc);
+}
+
+template <>
+inline detail::io_context_impl& use_service<detail::io_context_impl>(
+    io_context& ioc)
+{
+  return ioc.impl_;
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#if defined(ASIO_HAS_IOCP)
+# include "asio/detail/win_iocp_io_context.hpp"
+#else
+# include "asio/detail/scheduler.hpp"
+#endif
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+inline io_context::executor_type
+io_context::get_executor() ASIO_NOEXCEPT
+{
+  return executor_type(*this);
+}
+
+#if defined(ASIO_HAS_CHRONO)
+
+template <typename Rep, typename Period>
+std::size_t io_context::run_for(
+    const chrono::duration<Rep, Period>& rel_time)
+{
+  return this->run_until(chrono::steady_clock::now() + rel_time);
+}
+
+template <typename Clock, typename Duration>
+std::size_t io_context::run_until(
+    const chrono::time_point<Clock, Duration>& abs_time)
+{
+  std::size_t n = 0;
+  while (this->run_one_until(abs_time))
+    if (n != (std::numeric_limits<std::size_t>::max)())
+      ++n;
+  return n;
+}
+
+template <typename Rep, typename Period>
+std::size_t io_context::run_one_for(
+    const chrono::duration<Rep, Period>& rel_time)
+{
+  return this->run_one_until(chrono::steady_clock::now() + rel_time);
+}
+
+template <typename Clock, typename Duration>
+std::size_t io_context::run_one_until(
+    const chrono::time_point<Clock, Duration>& abs_time)
+{
+  typename Clock::time_point now = Clock::now();
+  while (now < abs_time)
+  {
+    typename Clock::duration rel_time = abs_time - now;
+    if (rel_time > chrono::seconds(1))
+      rel_time = chrono::seconds(1);
+
+    asio::error_code ec;
+    std::size_t s = impl_.wait_one(
+        static_cast<long>(chrono::duration_cast<
+          chrono::microseconds>(rel_time).count()), ec);
+    asio::detail::throw_error(ec);
+
+    if (s || impl_.stopped())
+      return s;
+
+    now = Clock::now();
+  }
+
+  return 0;
+}
+
+#endif // defined(ASIO_HAS_CHRONO)
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+inline void io_context::reset()
+{
+  restart();
+}
+
+template <typename LegacyCompletionHandler>
+ASIO_INITFN_RESULT_TYPE(LegacyCompletionHandler, void ())
+io_context::dispatch(ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a LegacyCompletionHandler.
+  ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
+      LegacyCompletionHandler, handler) type_check;
+
+  async_completion<LegacyCompletionHandler, void ()> init(handler);
+
+  if (impl_.can_dispatch())
+  {
+    detail::fenced_block b(detail::fenced_block::full);
+    asio_handler_invoke_helpers::invoke(
+        init.completion_handler, init.completion_handler);
+  }
+  else
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef detail::completion_handler<
+      typename handler_type<LegacyCompletionHandler, void ()>::type> op;
+    typename op::ptr p = { detail::addressof(init.completion_handler),
+      op::ptr::allocate(init.completion_handler), 0 };
+    p.p = new (p.v) op(init.completion_handler);
+
+    ASIO_HANDLER_CREATION((*this, *p.p,
+          "io_context", this, 0, "dispatch"));
+
+    impl_.do_dispatch(p.p);
+    p.v = p.p = 0;
+  }
+
+  return init.result.get();
+}
+
+template <typename LegacyCompletionHandler>
+ASIO_INITFN_RESULT_TYPE(LegacyCompletionHandler, void ())
+io_context::post(ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a LegacyCompletionHandler.
+  ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
+      LegacyCompletionHandler, handler) type_check;
+
+  async_completion<LegacyCompletionHandler, void ()> init(handler);
+
+  bool is_continuation =
+    asio_handler_cont_helpers::is_continuation(init.completion_handler);
+
+  // Allocate and construct an operation to wrap the handler.
+  typedef detail::completion_handler<
+    typename handler_type<LegacyCompletionHandler, void ()>::type> op;
+  typename op::ptr p = { detail::addressof(init.completion_handler),
+      op::ptr::allocate(init.completion_handler), 0 };
+  p.p = new (p.v) op(init.completion_handler);
+
+  ASIO_HANDLER_CREATION((*this, *p.p,
+        "io_context", this, 0, "post"));
+
+  impl_.post_immediate_completion(p.p, is_continuation);
+  p.v = p.p = 0;
+
+  return init.result.get();
+}
+
+template <typename Handler>
+#if defined(GENERATING_DOCUMENTATION)
+unspecified
+#else
+inline detail::wrapped_handler<io_context&, Handler>
+#endif
+io_context::wrap(Handler handler)
+{
+  return detail::wrapped_handler<io_context&, Handler>(*this, handler);
+}
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+inline io_context&
+io_context::executor_type::context() const ASIO_NOEXCEPT
+{
+  return io_context_;
+}
+
+inline void
+io_context::executor_type::on_work_started() const ASIO_NOEXCEPT
+{
+  io_context_.impl_.work_started();
+}
+
+inline void
+io_context::executor_type::on_work_finished() const ASIO_NOEXCEPT
+{
+  io_context_.impl_.work_finished();
+}
+
+template <typename Function, typename Allocator>
+void io_context::executor_type::dispatch(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Invoke immediately if we are already inside the thread pool.
+  if (io_context_.impl_.can_dispatch())
+  {
+    // Make a local, non-const copy of the function.
+    function_type tmp(ASIO_MOVE_CAST(Function)(f));
+
+    detail::fenced_block b(detail::fenced_block::full);
+    asio_handler_invoke_helpers::invoke(tmp, tmp);
+    return;
+  }
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((this->context(), *p.p,
+        "io_context", &this->context(), 0, "post"));
+
+  io_context_.impl_.post_immediate_completion(p.p, false);
+  p.v = p.p = 0;
+}
+
+template <typename Function, typename Allocator>
+void io_context::executor_type::post(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((this->context(), *p.p,
+        "io_context", &this->context(), 0, "post"));
+
+  io_context_.impl_.post_immediate_completion(p.p, false);
+  p.v = p.p = 0;
+}
+
+template <typename Function, typename Allocator>
+void io_context::executor_type::defer(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((this->context(), *p.p,
+        "io_context", &this->context(), 0, "defer"));
+
+  io_context_.impl_.post_immediate_completion(p.p, true);
+  p.v = p.p = 0;
+}
+
+inline bool
+io_context::executor_type::running_in_this_thread() const ASIO_NOEXCEPT
+{
+  return io_context_.impl_.can_dispatch();
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+inline io_context::work::work(asio::io_context& io_context)
+  : io_context_impl_(io_context.impl_)
+{
+  io_context_impl_.work_started();
+}
+
+inline io_context::work::work(const work& other)
+  : io_context_impl_(other.io_context_impl_)
+{
+  io_context_impl_.work_started();
+}
+
+inline io_context::work::~work()
+{
+  io_context_impl_.work_finished();
+}
+
+inline asio::io_context& io_context::work::get_io_context()
+{
+  return static_cast<asio::io_context&>(io_context_impl_.context());
+}
+
+inline asio::io_context& io_context::work::get_io_service()
+{
+  return static_cast<asio::io_context&>(io_context_impl_.context());
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+inline asio::io_context& io_context::service::get_io_context()
+{
+  return static_cast<asio::io_context&>(context());
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+inline asio::io_context& io_context::service::get_io_service()
+{
+  return static_cast<asio::io_context&>(context());
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_IO_CONTEXT_HPP
diff --git a/extern/include/asio/impl/io_context.ipp b/extern/include/asio/impl/io_context.ipp
new file mode 100644
index 00000000..7eb467d2
--- /dev/null
+++ b/extern/include/asio/impl/io_context.ipp
@@ -0,0 +1,174 @@
+//
+// impl/io_context.ipp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_IO_CONTEXT_IPP
+#define ASIO_IMPL_IO_CONTEXT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/io_context.hpp"
+#include "asio/detail/concurrency_hint.hpp"
+#include "asio/detail/limits.hpp"
+#include "asio/detail/scoped_ptr.hpp"
+#include "asio/detail/service_registry.hpp"
+#include "asio/detail/throw_error.hpp"
+
+#if defined(ASIO_HAS_IOCP)
+# include "asio/detail/win_iocp_io_context.hpp"
+#else
+# include "asio/detail/scheduler.hpp"
+#endif
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+io_context::io_context()
+  : impl_(add_impl(new impl_type(*this, ASIO_CONCURRENCY_HINT_DEFAULT)))
+{
+}
+
+io_context::io_context(int concurrency_hint)
+  : impl_(add_impl(new impl_type(*this, concurrency_hint == 1
+          ? ASIO_CONCURRENCY_HINT_1 : concurrency_hint)))
+{
+}
+
+io_context::impl_type& io_context::add_impl(io_context::impl_type* impl)
+{
+  asio::detail::scoped_ptr<impl_type> scoped_impl(impl);
+  asio::add_service<impl_type>(*this, scoped_impl.get());
+  return *scoped_impl.release();
+}
+
+io_context::~io_context()
+{
+}
+
+io_context::count_type io_context::run()
+{
+  asio::error_code ec;
+  count_type s = impl_.run(ec);
+  asio::detail::throw_error(ec);
+  return s;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+io_context::count_type io_context::run(asio::error_code& ec)
+{
+  return impl_.run(ec);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+io_context::count_type io_context::run_one()
+{
+  asio::error_code ec;
+  count_type s = impl_.run_one(ec);
+  asio::detail::throw_error(ec);
+  return s;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+io_context::count_type io_context::run_one(asio::error_code& ec)
+{
+  return impl_.run_one(ec);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+io_context::count_type io_context::poll()
+{
+  asio::error_code ec;
+  count_type s = impl_.poll(ec);
+  asio::detail::throw_error(ec);
+  return s;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+io_context::count_type io_context::poll(asio::error_code& ec)
+{
+  return impl_.poll(ec);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+io_context::count_type io_context::poll_one()
+{
+  asio::error_code ec;
+  count_type s = impl_.poll_one(ec);
+  asio::detail::throw_error(ec);
+  return s;
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+io_context::count_type io_context::poll_one(asio::error_code& ec)
+{
+  return impl_.poll_one(ec);
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+void io_context::stop()
+{
+  impl_.stop();
+}
+
+bool io_context::stopped() const
+{
+  return impl_.stopped();
+}
+
+void io_context::restart()
+{
+  impl_.restart();
+}
+
+io_context::service::service(asio::io_context& owner)
+  : execution_context::service(owner)
+{
+}
+
+io_context::service::~service()
+{
+}
+
+void io_context::service::shutdown()
+{
+#if !defined(ASIO_NO_DEPRECATED)
+  shutdown_service();
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+void io_context::service::shutdown_service()
+{
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+void io_context::service::notify_fork(io_context::fork_event ev)
+{
+#if !defined(ASIO_NO_DEPRECATED)
+  fork_service(ev);
+#else // !defined(ASIO_NO_DEPRECATED)
+  (void)ev;
+#endif // !defined(ASIO_NO_DEPRECATED)
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
+void io_context::service::fork_service(io_context::fork_event)
+{
+}
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_IO_CONTEXT_IPP
diff --git a/extern/include/asio/impl/io_service.hpp b/extern/include/asio/impl/io_service.hpp
deleted file mode 100644
index b20f546c..00000000
--- a/extern/include/asio/impl/io_service.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// impl/io_service.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_IO_SERVICE_HPP
-#define ASIO_IMPL_IO_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/service_registry.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename Service>
-inline Service& use_service(io_service& ios)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<io_service::service*>(static_cast<Service*>(0));
-  (void)static_cast<const io_service::id*>(&Service::id);
-
-  return ios.service_registry_->template use_service<Service>();
-}
-
-template <>
-inline detail::io_service_impl& use_service<detail::io_service_impl>(
-    io_service& ios)
-{
-  return ios.impl_;
-}
-
-template <typename Service>
-inline void add_service(io_service& ios, Service* svc)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<io_service::service*>(static_cast<Service*>(0));
-  (void)static_cast<const io_service::id*>(&Service::id);
-
-  ios.service_registry_->template add_service<Service>(svc);
-}
-
-template <typename Service>
-inline bool has_service(io_service& ios)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<io_service::service*>(static_cast<Service*>(0));
-  (void)static_cast<const io_service::id*>(&Service::id);
-
-  return ios.service_registry_->template has_service<Service>();
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_service.hpp"
-#else
-# include "asio/detail/task_io_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename CompletionHandler>
-inline ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
-io_service::dispatch(ASIO_MOVE_ARG(CompletionHandler) 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.
-  ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
-
-  detail::async_result_init<
-    CompletionHandler, void ()> init(
-      ASIO_MOVE_CAST(CompletionHandler)(handler));
-
-  impl_.dispatch(init.handler);
-
-  return init.result.get();
-}
-
-template <typename CompletionHandler>
-inline ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
-io_service::post(ASIO_MOVE_ARG(CompletionHandler) 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.
-  ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
-
-  detail::async_result_init<
-    CompletionHandler, void ()> init(
-      ASIO_MOVE_CAST(CompletionHandler)(handler));
-
-  impl_.post(init.handler);
-
-  return init.result.get();
-}
-
-template <typename Handler>
-#if defined(GENERATING_DOCUMENTATION)
-unspecified
-#else
-inline detail::wrapped_handler<io_service&, Handler>
-#endif
-io_service::wrap(Handler handler)
-{
-  return detail::wrapped_handler<io_service&, Handler>(*this, handler);
-}
-
-inline io_service::work::work(asio::io_service& io_service)
-  : io_service_impl_(io_service.impl_)
-{
-  io_service_impl_.work_started();
-}
-
-inline io_service::work::work(const work& other)
-  : io_service_impl_(other.io_service_impl_)
-{
-  io_service_impl_.work_started();
-}
-
-inline io_service::work::~work()
-{
-  io_service_impl_.work_finished();
-}
-
-inline asio::io_service& io_service::work::get_io_service()
-{
-  return io_service_impl_.get_io_service();
-}
-
-inline asio::io_service& io_service::service::get_io_service()
-{
-  return owner_;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_IO_SERVICE_HPP
diff --git a/extern/include/asio/impl/io_service.ipp b/extern/include/asio/impl/io_service.ipp
deleted file mode 100644
index 952c1bd2..00000000
--- a/extern/include/asio/impl/io_service.ipp
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-// impl/io_service.ipp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_IO_SERVICE_IPP
-#define ASIO_IMPL_IO_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/service_registry.hpp"
-#include "asio/detail/throw_error.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_service.hpp"
-#else
-# include "asio/detail/task_io_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-io_service::io_service()
-  : service_registry_(new asio::detail::service_registry(
-        *this, static_cast<impl_type*>(0),
-        (std::numeric_limits<std::size_t>::max)())),
-    impl_(service_registry_->first_service<impl_type>())
-{
-}
-
-io_service::io_service(std::size_t concurrency_hint)
-  : service_registry_(new asio::detail::service_registry(
-        *this, static_cast<impl_type*>(0), concurrency_hint)),
-    impl_(service_registry_->first_service<impl_type>())
-{
-}
-
-io_service::~io_service()
-{
-  delete service_registry_;
-}
-
-std::size_t io_service::run()
-{
-  asio::error_code ec;
-  std::size_t s = impl_.run(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-std::size_t io_service::run(asio::error_code& ec)
-{
-  return impl_.run(ec);
-}
-
-std::size_t io_service::run_one()
-{
-  asio::error_code ec;
-  std::size_t s = impl_.run_one(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-std::size_t io_service::run_one(asio::error_code& ec)
-{
-  return impl_.run_one(ec);
-}
-
-std::size_t io_service::poll()
-{
-  asio::error_code ec;
-  std::size_t s = impl_.poll(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-std::size_t io_service::poll(asio::error_code& ec)
-{
-  return impl_.poll(ec);
-}
-
-std::size_t io_service::poll_one()
-{
-  asio::error_code ec;
-  std::size_t s = impl_.poll_one(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-std::size_t io_service::poll_one(asio::error_code& ec)
-{
-  return impl_.poll_one(ec);
-}
-
-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(asio::io_service::fork_event event)
-{
-  service_registry_->notify_fork(event);
-}
-
-io_service::service::service(asio::io_service& owner)
-  : owner_(owner),
-    next_(0)
-{
-}
-
-io_service::service::~service()
-{
-}
-
-void io_service::service::fork_service(asio::io_service::fork_event)
-{
-}
-
-service_already_exists::service_already_exists()
-  : std::logic_error("Service already exists.")
-{
-}
-
-invalid_service_owner::invalid_service_owner()
-  : std::logic_error("Invalid service owner.")
-{
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_IO_SERVICE_IPP
diff --git a/extern/include/asio/impl/post.hpp b/extern/include/asio/impl/post.hpp
new file mode 100644
index 00000000..55389532
--- /dev/null
+++ b/extern/include/asio/impl/post.hpp
@@ -0,0 +1,77 @@
+//
+// impl/post.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_POST_HPP
+#define ASIO_IMPL_POST_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/detail/work_dispatcher.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
+    ASIO_MOVE_ARG(CompletionToken) token)
+{
+  typedef ASIO_HANDLER_TYPE(CompletionToken, void()) handler;
+
+  async_completion<CompletionToken, void()> init(token);
+
+  typename associated_executor<handler>::type ex(
+      (get_associated_executor)(init.completion_handler));
+
+  typename associated_allocator<handler>::type alloc(
+      (get_associated_allocator)(init.completion_handler));
+
+  ex.post(ASIO_MOVE_CAST(handler)(init.completion_handler), alloc);
+
+  return init.result.get();
+}
+
+template <typename Executor, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
+    const Executor& ex, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_executor<Executor>::value>::type*)
+{
+  typedef ASIO_HANDLER_TYPE(CompletionToken, void()) handler;
+
+  async_completion<CompletionToken, void()> init(token);
+
+  typename associated_allocator<handler>::type alloc(
+      (get_associated_allocator)(init.completion_handler));
+
+  ex.post(detail::work_dispatcher<handler>(init.completion_handler), alloc);
+
+  return init.result.get();
+}
+
+template <typename ExecutionContext, typename CompletionToken>
+inline ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
+    ExecutionContext& ctx, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type*)
+{
+  return (post)(ctx.get_executor(),
+      ASIO_MOVE_CAST(CompletionToken)(token));
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_POST_HPP
diff --git a/extern/include/asio/impl/read.hpp b/extern/include/asio/impl/read.hpp
index 159bb538..603a7a9b 100644
--- a/extern/include/asio/impl/read.hpp
+++ b/extern/include/asio/impl/read.hpp
@@ -2,7 +2,7 @@
 // impl/read.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/buffer.hpp"
 #include "asio/completion_condition.hpp"
 #include "asio/detail/array_fwd.hpp"
@@ -34,30 +36,46 @@
 
 namespace asio {
 
+namespace detail
+{
+  template <typename SyncReadStream, typename MutableBufferSequence,
+      typename MutableBufferIterator, typename CompletionCondition>
+  std::size_t read_buffer_sequence(SyncReadStream& s,
+      const MutableBufferSequence& buffers, const MutableBufferIterator&,
+      CompletionCondition completion_condition, asio::error_code& ec)
+  {
+    ec = asio::error_code();
+    asio::detail::consuming_buffers<mutable_buffer,
+        MutableBufferSequence, MutableBufferIterator> tmp(buffers);
+    while (!tmp.empty())
+    {
+      if (std::size_t max_size = detail::adapt_completion_condition_result(
+            completion_condition(ec, tmp.total_consumed())))
+        tmp.consume(s.read_some(tmp.prepare(max_size), ec));
+      else
+        break;
+    }
+    return tmp.total_consumed();;
+  }
+} // namespace detail
+
 template <typename SyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec)
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type*)
 {
-  ec = asio::error_code();
-  asio::detail::consuming_buffers<
-    mutable_buffer, MutableBufferSequence> tmp(buffers);
-  std::size_t total_transferred = 0;
-  tmp.prepare(detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred)));
-  while (tmp.begin() != tmp.end())
-  {
-    std::size_t bytes_transferred = s.read_some(tmp, ec);
-    tmp.consume(bytes_transferred);
-    total_transferred += bytes_transferred;
-    tmp.prepare(detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred)));
-  }
-  return total_transferred;
+  return detail::read_buffer_sequence(s, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition, ec);
 }
 
 template <typename SyncReadStream, typename MutableBufferSequence>
-inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
+inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type*)
 {
   asio::error_code ec;
   std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
@@ -67,7 +85,10 @@ inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
 
 template <typename SyncReadStream, typename MutableBufferSequence>
 inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    asio::error_code& ec)
+    asio::error_code& ec,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type*)
 {
   return read(s, buffers, transfer_all(), ec);
 }
@@ -75,7 +96,10 @@ inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
 template <typename SyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition>
 inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition)
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type*)
 {
   asio::error_code ec;
   std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
@@ -83,19 +107,25 @@ inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
   return bytes_transferred;
 }
 
-#if !defined(ASIO_NO_IOSTREAM)
-
-template <typename SyncReadStream, typename Allocator,
+template <typename SyncReadStream, typename DynamicBuffer,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
 {
+  typename decay<DynamicBuffer>::type b(
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   ec = asio::error_code();
   std::size_t total_transferred = 0;
   std::size_t max_size = detail::adapt_completion_condition_result(
         completion_condition(ec, total_transferred));
-  std::size_t bytes_available = read_size_helper(b, max_size);
+  std::size_t bytes_available = std::min<std::size_t>(
+        std::max<std::size_t>(512, b.capacity() - b.size()),
+        std::min<std::size_t>(max_size, b.max_size() - b.size()));
   while (bytes_available > 0)
   {
     std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);
@@ -103,27 +133,81 @@ std::size_t read(SyncReadStream& s,
     total_transferred += bytes_transferred;
     max_size = detail::adapt_completion_condition_result(
           completion_condition(ec, total_transferred));
-    bytes_available = read_size_helper(b, max_size);
+    bytes_available = std::min<std::size_t>(
+          std::max<std::size_t>(512, b.capacity() - b.size()),
+          std::min<std::size_t>(max_size, b.max_size() - b.size()));
   }
   return total_transferred;
 }
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 inline std::size_t read(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
 {
   asio::error_code ec;
-  std::size_t bytes_transferred = read(s, b, transfer_all(), ec);
+  std::size_t bytes_transferred = read(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers), transfer_all(), ec);
   asio::detail::throw_error(ec, "read");
   return bytes_transferred;
 }
 
+template <typename SyncReadStream, typename DynamicBuffer>
+inline std::size_t read(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
+{
+  return read(s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), ec);
+}
+
+template <typename SyncReadStream, typename DynamicBuffer,
+    typename CompletionCondition>
+inline std::size_t read(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
+{
+  asio::error_code ec;
+  std::size_t bytes_transferred = read(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      completion_condition, ec);
+  asio::detail::throw_error(ec, "read");
+  return bytes_transferred;
+}
+
+#if !defined(ASIO_NO_EXTENSIONS)
+#if !defined(ASIO_NO_IOSTREAM)
+
+template <typename SyncReadStream, typename Allocator,
+    typename CompletionCondition>
+inline std::size_t read(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, asio::error_code& ec)
+{
+  return read(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b)
+{
+  return read(s, basic_streambuf_ref<Allocator>(b));
+}
+
 template <typename SyncReadStream, typename Allocator>
 inline std::size_t read(SyncReadStream& s,
     asio::basic_streambuf<Allocator>& b,
     asio::error_code& ec)
 {
-  return read(s, b, transfer_all(), ec);
+  return read(s, basic_streambuf_ref<Allocator>(b), ec);
 }
 
 template <typename SyncReadStream, typename Allocator,
@@ -132,18 +216,17 @@ inline std::size_t read(SyncReadStream& s,
     asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition)
 {
-  asio::error_code ec;
-  std::size_t bytes_transferred = read(s, b, completion_condition, ec);
-  asio::detail::throw_error(ec, "read");
-  return bytes_transferred;
+  return read(s, basic_streambuf_ref<Allocator>(b), completion_condition);
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 namespace detail
 {
   template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename CompletionCondition, typename ReadHandler>
+      typename MutableBufferIterator, typename CompletionCondition,
+      typename ReadHandler>
   class read_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
@@ -155,7 +238,6 @@ namespace detail
         stream_(stream),
         buffers_(buffers),
         start_(0),
-        total_transferred_(0),
         handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
@@ -166,7 +248,6 @@ namespace detail
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
@@ -176,7 +257,6 @@ namespace detail
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
     }
@@ -185,285 +265,39 @@ namespace detail
     void operator()(const asio::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
+      std::size_t max_size;
       switch (start_ = start)
       {
         case 1:
-        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-        for (;;)
+        max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        do
         {
-          stream_.async_read_some(buffers_,
+          stream_.async_read_some(buffers_.prepare(max_size),
               ASIO_MOVE_CAST(read_op)(*this));
           return; default:
-          total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
-          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-          if ((!ec && bytes_transferred == 0)
-              || buffers_.begin() == buffers_.end())
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    asio::detail::consuming_buffers<
-      mutable_buffer, MutableBufferSequence> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream,
-      typename CompletionCondition, typename ReadHandler>
-  class read_op<AsyncReadStream, asio::mutable_buffers_1,
-      CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_op(AsyncReadStream& stream,
-        const asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
-    {
-    }
-
-#if defined(ASIO_HAS_MOVE)
-    read_op(const read_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          stream_.async_read_some(
-              asio::buffer(buffer_ + total_transferred_, n),
-              ASIO_MOVE_CAST(read_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    asio::mutable_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename Elem,
-      typename CompletionCondition, typename ReadHandler>
-  class read_op<AsyncReadStream, boost::array<Elem, 2>,
-      CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_op(AsyncReadStream& stream, const boost::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
-    {
-    }
-
-#if defined(ASIO_HAS_MOVE)
-    read_op(const read_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          boost::array<asio::mutable_buffer, 2> >::type bufs = {{
-        asio::mutable_buffer(buffers_[0]),
-        asio::mutable_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          stream_.async_read_some(bufs, ASIO_MOVE_CAST(read_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    boost::array<Elem, 2> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-#if defined(ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncReadStream, typename Elem,
-      typename CompletionCondition, typename ReadHandler>
-  class read_op<AsyncReadStream, std::array<Elem, 2>,
-      CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
-    {
-    }
-
-#if defined(ASIO_HAS_MOVE)
-    read_op(const read_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          std::array<asio::mutable_buffer, 2> >::type bufs = {{
-        asio::mutable_buffer(buffers_[0]),
-        asio::mutable_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          stream_.async_read_some(bufs, ASIO_MOVE_CAST(read_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
+          if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
-        }
+          max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        } while (max_size > 0);
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        handler_(ec, buffers_.total_consumed());
       }
     }
 
   //private:
     AsyncReadStream& stream_;
-    std::array<Elem, 2> buffers_;
+    asio::detail::consuming_buffers<mutable_buffer,
+        MutableBufferSequence, MutableBufferIterator> buffers_;
     int start_;
-    std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
-#endif // defined(ASIO_HAS_STD_ARRAY)
-
   template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename CompletionCondition, typename ReadHandler>
+      typename MutableBufferIterator, typename CompletionCondition,
+      typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      read_op<AsyncReadStream, MutableBufferSequence,
+      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
@@ -471,9 +305,10 @@ namespace detail
   }
 
   template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename CompletionCondition, typename ReadHandler>
+      typename MutableBufferIterator, typename CompletionCondition,
+      typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      read_op<AsyncReadStream, MutableBufferSequence,
+      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
@@ -481,9 +316,10 @@ namespace detail
   }
 
   template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename CompletionCondition, typename ReadHandler>
+      typename MutableBufferIterator, typename CompletionCondition,
+      typename ReadHandler>
   inline bool asio_handler_is_continuation(
-      read_op<AsyncReadStream, MutableBufferSequence,
+      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
@@ -492,10 +328,10 @@ namespace detail
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
-      read_op<AsyncReadStream, MutableBufferSequence,
+      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
@@ -503,38 +339,93 @@ namespace detail
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
-      read_op<AsyncReadStream, MutableBufferSequence,
+      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncReadStream, typename MutableBufferSequence,
+      typename MutableBufferIterator, typename CompletionCondition,
+      typename ReadHandler>
+  inline void start_read_buffer_sequence_op(AsyncReadStream& stream,
+      const MutableBufferSequence& buffers, const MutableBufferIterator&,
+      CompletionCondition completion_condition, ReadHandler& handler)
+  {
+    detail::read_op<AsyncReadStream, MutableBufferSequence,
+      MutableBufferIterator, CompletionCondition, ReadHandler>(
+        stream, buffers, completion_condition, handler)(
+          asio::error_code(), 0, 1);
+  }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename MutableBufferSequence,
+    typename MutableBufferIterator, typename CompletionCondition,
+    typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_op<AsyncReadStream, MutableBufferSequence,
+      MutableBufferIterator, CompletionCondition, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_op<AsyncReadStream, MutableBufferSequence,
+        MutableBufferIterator, CompletionCondition, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename MutableBufferSequence,
+    typename MutableBufferIterator, typename CompletionCondition,
+    typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_op<AsyncReadStream, MutableBufferSequence,
+      MutableBufferIterator, CompletionCondition, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_op<AsyncReadStream, MutableBufferSequence,
+        MutableBufferIterator, CompletionCondition, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::read_op<AsyncReadStream, MutableBufferSequence,
-    CompletionCondition, ASIO_HANDLER_TYPE(
-      ReadHandler, void (asio::error_code, std::size_t))>(
-        s, buffers, completion_condition, init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_read_buffer_sequence_op(s, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition,
+      init.completion_handler);
 
   return init.result.get();
 }
@@ -544,42 +435,41 @@ template <typename AsyncReadStream, typename MutableBufferSequence,
 inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::read_op<AsyncReadStream, MutableBufferSequence,
-    detail::transfer_all_t, ASIO_HANDLER_TYPE(
-      ReadHandler, void (asio::error_code, std::size_t))>(
-        s, buffers, transfer_all(), init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_read_buffer_sequence_op(s, buffers,
+      asio::buffer_sequence_begin(buffers), transfer_all(),
+      init.completion_handler);
 
   return init.result.get();
 }
 
-#if !defined(ASIO_NO_IOSTREAM)
-
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename CompletionCondition, typename ReadHandler>
-  class read_streambuf_op
+  class read_dynbuf_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
   public:
-    read_streambuf_op(AsyncReadStream& stream,
-        basic_streambuf<Allocator>& streambuf,
+    template <typename BufferSequence>
+    read_dynbuf_op(AsyncReadStream& stream,
+        ASIO_MOVE_ARG(BufferSequence) buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
-        streambuf_(streambuf),
+        buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),
         start_(0),
         total_transferred_(0),
         handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
@@ -587,20 +477,20 @@ namespace detail
     }
 
 #if defined(ASIO_HAS_MOVE)
-    read_streambuf_op(const read_streambuf_op& other)
+    read_dynbuf_op(const read_dynbuf_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
-    read_streambuf_op(read_streambuf_op&& other)
+    read_dynbuf_op(read_dynbuf_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
@@ -616,16 +506,24 @@ namespace detail
       {
         case 1:
         max_size = this->check_for_completion(ec, total_transferred_);
-        bytes_available = read_size_helper(streambuf_, max_size);
+        bytes_available = std::min<std::size_t>(
+              std::max<std::size_t>(512,
+                buffers_.capacity() - buffers_.size()),
+              std::min<std::size_t>(max_size,
+                buffers_.max_size() - buffers_.size()));
         for (;;)
         {
-          stream_.async_read_some(streambuf_.prepare(bytes_available),
-              ASIO_MOVE_CAST(read_streambuf_op)(*this));
+          stream_.async_read_some(buffers_.prepare(bytes_available),
+              ASIO_MOVE_CAST(read_dynbuf_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           max_size = this->check_for_completion(ec, total_transferred_);
-          bytes_available = read_size_helper(streambuf_, max_size);
+          bytes_available = std::min<std::size_t>(
+                std::max<std::size_t>(512,
+                  buffers_.capacity() - buffers_.size()),
+                std::min<std::size_t>(max_size,
+                  buffers_.max_size() - buffers_.size()));
           if ((!ec && bytes_transferred == 0) || bytes_available == 0)
             break;
         }
@@ -636,36 +534,36 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename CompletionCondition, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      read_streambuf_op<AsyncReadStream, Allocator,
+      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      read_streambuf_op<AsyncReadStream, Allocator,
+      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
         CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename CompletionCondition, typename ReadHandler>
   inline bool asio_handler_is_continuation(
-      read_streambuf_op<AsyncReadStream, Allocator,
+      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
@@ -674,9 +572,10 @@ namespace detail
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename CompletionCondition, typename ReadHandler>
+      typename DynamicBuffer, typename CompletionCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
-      read_streambuf_op<AsyncReadStream, Allocator,
+      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
         CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
@@ -684,9 +583,10 @@ namespace detail
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename CompletionCondition, typename ReadHandler>
+      typename DynamicBuffer, typename CompletionCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
-      read_streambuf_op<AsyncReadStream, Allocator,
+      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
         CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
@@ -694,57 +594,119 @@ namespace detail
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator,
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename CompletionCondition, typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_dynbuf_op<AsyncReadStream,
+      DynamicBuffer, CompletionCondition, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_dynbuf_op<AsyncReadStream,
+        DynamicBuffer, CompletionCondition, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename CompletionCondition, typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_dynbuf_op<AsyncReadStream,
+      DynamicBuffer, CompletionCondition, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_dynbuf_op<AsyncReadStream,
+        DynamicBuffer, CompletionCondition, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
+inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read(AsyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
+{
+  return async_read(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+template <typename AsyncReadStream, typename DynamicBuffer,
     typename CompletionCondition, typename ReadHandler>
 inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::read_streambuf_op<AsyncReadStream, Allocator,
-    CompletionCondition, ASIO_HANDLER_TYPE(
-      ReadHandler, void (asio::error_code, std::size_t))>(
-        s, b, completion_condition, init.handler)(
-          asio::error_code(), 0, 1);
+  detail::read_dynbuf_op<AsyncReadStream,
+    typename decay<DynamicBuffer>::type,
+      CompletionCondition, ASIO_HANDLER_TYPE(
+        ReadHandler, void (asio::error_code, std::size_t))>(
+          s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            completion_condition, init.completion_handler)(
+              asio::error_code(), 0, 1);
 
   return init.result.get();
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
+#if !defined(ASIO_NO_IOSTREAM)
+
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
-async_read(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
+async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     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.
-  ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
+  return async_read(s, basic_streambuf_ref<Allocator>(b),
       ASIO_MOVE_CAST(ReadHandler)(handler));
+}
 
-  detail::read_streambuf_op<AsyncReadStream, Allocator,
-    detail::transfer_all_t, ASIO_HANDLER_TYPE(
-      ReadHandler, void (asio::error_code, std::size_t))>(
-        s, b, transfer_all(), init.handler)(
-          asio::error_code(), 0, 1);
-
-  return init.result.get();
+template <typename AsyncReadStream, typename Allocator,
+    typename CompletionCondition, typename ReadHandler>
+inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  return async_read(s, basic_streambuf_ref<Allocator>(b),
+      completion_condition, ASIO_MOVE_CAST(ReadHandler)(handler));
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 } // namespace asio
 
diff --git a/extern/include/asio/impl/read_at.hpp b/extern/include/asio/impl/read_at.hpp
index 723b9dd5..d736d4d3 100644
--- a/extern/include/asio/impl/read_at.hpp
+++ b/extern/include/asio/impl/read_at.hpp
@@ -2,7 +2,7 @@
 // impl/read_at.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/buffer.hpp"
 #include "asio/completion_condition.hpp"
 #include "asio/detail/array_fwd.hpp"
@@ -34,28 +36,41 @@
 
 namespace asio {
 
+namespace detail
+{
+  template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
+      typename MutableBufferIterator, typename CompletionCondition>
+  std::size_t read_at_buffer_sequence(SyncRandomAccessReadDevice& d,
+      uint64_t offset, const MutableBufferSequence& buffers,
+      const MutableBufferIterator&, CompletionCondition completion_condition,
+      asio::error_code& ec)
+  {
+    ec = asio::error_code();
+    asio::detail::consuming_buffers<mutable_buffer,
+        MutableBufferSequence, MutableBufferIterator> tmp(buffers);
+    while (!tmp.empty())
+    {
+      if (std::size_t max_size = detail::adapt_completion_condition_result(
+            completion_condition(ec, tmp.total_consumed())))
+      {
+        tmp.consume(d.read_some_at(offset + tmp.total_consumed(),
+              tmp.prepare(max_size), ec));
+      }
+      else
+        break;
+    }
+    return tmp.total_consumed();;
+  }
+} // namespace detail
+
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition, asio::error_code& ec)
 {
-  ec = asio::error_code();
-  asio::detail::consuming_buffers<
-    mutable_buffer, MutableBufferSequence> tmp(buffers);
-  std::size_t total_transferred = 0;
-  tmp.prepare(detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred)));
-  while (tmp.begin() != tmp.end())
-  {
-    std::size_t bytes_transferred = d.read_some_at(
-        offset + total_transferred, tmp, ec);
-    tmp.consume(bytes_transferred);
-    total_transferred += bytes_transferred;
-    tmp.prepare(detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred)));
-  }
-  return total_transferred;
+  return detail::read_at_buffer_sequence(d, offset, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition, ec);
 }
 
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
@@ -90,6 +105,7 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
   return bytes_transferred;
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 template <typename SyncRandomAccessReadDevice, typename Allocator,
@@ -149,12 +165,13 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d,
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 namespace detail
 {
   template <typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
   class read_at_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
@@ -168,7 +185,6 @@ namespace detail
         offset_(offset),
         buffers_(buffers),
         start_(0),
-        total_transferred_(0),
         handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
@@ -180,7 +196,6 @@ namespace detail
         offset_(other.offset_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
@@ -191,7 +206,6 @@ namespace detail
         offset_(other.offset_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
     {
     }
@@ -200,326 +214,64 @@ namespace detail
     void operator()(const asio::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
+      std::size_t max_size;
       switch (start_ = start)
       {
         case 1:
-        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-        for (;;)
+        max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        do
         {
-          device_.async_read_some_at(offset_ + total_transferred_,
-              buffers_, ASIO_MOVE_CAST(read_at_op)(*this));
+          device_.async_read_some_at(
+              offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
+              ASIO_MOVE_CAST(read_at_op)(*this));
           return; default:
-          total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
-          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-          if ((!ec && bytes_transferred == 0)
-              || buffers_.begin() == buffers_.end())
+          if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
-        }
+          max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        } while (max_size > 0);
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        handler_(ec, buffers_.total_consumed());
       }
     }
 
   //private:
     AsyncRandomAccessReadDevice& device_;
     uint64_t offset_;
-    asio::detail::consuming_buffers<
-      mutable_buffer, MutableBufferSequence> buffers_;
+    asio::detail::consuming_buffers<mutable_buffer,
+        MutableBufferSequence, MutableBufferIterator> buffers_;
     int start_;
-    std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename MutableBufferIterator,
       typename CompletionCondition, typename ReadHandler>
-  class read_at_op<AsyncRandomAccessReadDevice,
-      asio::mutable_buffers_1, CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_at_op(AsyncRandomAccessReadDevice& device,
-        uint64_t offset, const asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
-    {
-    }
-
-#if defined(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_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          device_.async_read_some_at(offset_ + total_transferred_,
-              asio::buffer(buffer_ + total_transferred_, n),
-              ASIO_MOVE_CAST(read_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessReadDevice& device_;
-    uint64_t offset_;
-    asio::mutable_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncRandomAccessReadDevice, typename Elem,
-      typename CompletionCondition, typename ReadHandler>
-  class read_at_op<AsyncRandomAccessReadDevice, boost::array<Elem, 2>,
-      CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_at_op(AsyncRandomAccessReadDevice& device,
-        uint64_t offset, const boost::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
-    {
-    }
-
-#if defined(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_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          boost::array<asio::mutable_buffer, 2> >::type bufs = {{
-        asio::mutable_buffer(buffers_[0]),
-        asio::mutable_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          device_.async_read_some_at(offset_ + total_transferred_,
-              bufs, ASIO_MOVE_CAST(read_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessReadDevice& device_;
-    uint64_t offset_;
-    boost::array<Elem, 2> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-#if defined(ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncRandomAccessReadDevice, typename Elem,
-      typename CompletionCondition, typename ReadHandler>
-  class read_at_op<AsyncRandomAccessReadDevice, std::array<Elem, 2>,
-      CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_at_op(AsyncRandomAccessReadDevice& device,
-        uint64_t offset, const std::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(handler))
-    {
-    }
-
-#if defined(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_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          std::array<asio::mutable_buffer, 2> >::type bufs = {{
-        asio::mutable_buffer(buffers_[0]),
-        asio::mutable_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          device_.async_read_some_at(offset_ + total_transferred_,
-              bufs, ASIO_MOVE_CAST(read_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessReadDevice& device_;
-    uint64_t offset_;
-    std::array<Elem, 2> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-#endif // defined(ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-        CompletionCondition, ReadHandler>* this_handler)
+        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-        CompletionCondition, ReadHandler>* this_handler)
+        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
   template <typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
   inline bool asio_handler_is_continuation(
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-        CompletionCondition, ReadHandler>* this_handler)
+        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : asio_handler_cont_helpers::is_continuation(
@@ -527,42 +279,86 @@ namespace detail
   }
 
   template <typename Function, typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-        CompletionCondition, ReadHandler>* this_handler)
+        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
   template <typename Function, typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-        CompletionCondition, ReadHandler>* this_handler)
+        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
   {
     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,
+      typename MutableBufferSequence, typename MutableBufferIterator,
+      typename CompletionCondition, typename ReadHandler>
+  inline void start_read_at_buffer_sequence_op(AsyncRandomAccessReadDevice& d,
       uint64_t offset, const MutableBufferSequence& buffers,
-      CompletionCondition completion_condition, ReadHandler handler)
+      const MutableBufferIterator&, CompletionCondition completion_condition,
+      ReadHandler& handler)
   {
-    return read_at_op<AsyncRandomAccessReadDevice,
-      MutableBufferSequence, CompletionCondition, ReadHandler>(
-        d, offset, buffers, completion_condition, handler);
+    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+      MutableBufferIterator, CompletionCondition, ReadHandler>(
+        d, offset, buffers, completion_condition, handler)(
+          asio::error_code(), 0, 1);
   }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncRandomAccessReadDevice,
+    typename MutableBufferSequence, typename MutableBufferIterator,
+    typename CompletionCondition, typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+    MutableBufferIterator, CompletionCondition, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_at_op<AsyncRandomAccessReadDevice,
+      MutableBufferSequence, MutableBufferIterator,
+      CompletionCondition, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncRandomAccessReadDevice,
+    typename MutableBufferSequence, typename MutableBufferIterator,
+    typename CompletionCondition, typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+    MutableBufferIterator, CompletionCondition, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_at_op<AsyncRandomAccessReadDevice,
+      MutableBufferSequence, MutableBufferIterator,
+      CompletionCondition, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
@@ -576,15 +372,12 @@ async_read_at(AsyncRandomAccessReadDevice& d,
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-    CompletionCondition, ASIO_HANDLER_TYPE(ReadHandler,
-      void (asio::error_code, std::size_t))>(
-        d, offset, buffers, completion_condition, init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_read_at_buffer_sequence_op(d, offset, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition,
+      init.completion_handler);
 
   return init.result.get();
 }
@@ -601,19 +394,17 @@ async_read_at(AsyncRandomAccessReadDevice& d,
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-    detail::transfer_all_t, ASIO_HANDLER_TYPE(ReadHandler,
-      void (asio::error_code, std::size_t))>(
-        d, offset, buffers, transfer_all(), init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_read_at_buffer_sequence_op(d, offset, buffers,
+      asio::buffer_sequence_begin(buffers), transfer_all(),
+      init.completion_handler);
 
   return init.result.get();
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 namespace detail
@@ -750,6 +541,46 @@ namespace detail
   }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncRandomAccessReadDevice, typename Allocator,
+    typename CompletionCondition, typename ReadHandler, typename Allocator1>
+struct associated_allocator<
+    detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
+      Allocator, CompletionCondition, ReadHandler>,
+    Allocator1>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator1>::type type;
+
+  static type get(
+      const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
+        Allocator, CompletionCondition, ReadHandler>& h,
+      const Allocator1& a = Allocator1()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator1>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncRandomAccessReadDevice, typename Executor,
+    typename CompletionCondition, typename ReadHandler, typename Executor1>
+struct associated_executor<
+    detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
+      Executor, CompletionCondition, ReadHandler>,
+    Executor1>
+{
+  typedef typename associated_executor<ReadHandler, Executor1>::type type;
+
+  static type get(
+      const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
+        Executor, CompletionCondition, ReadHandler>& h,
+      const Executor1& ex = Executor1()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor1>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
 inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
@@ -763,14 +594,13 @@ async_read_at(AsyncRandomAccessReadDevice& d,
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
     CompletionCondition, ASIO_HANDLER_TYPE(ReadHandler,
       void (asio::error_code, std::size_t))>(
-        d, offset, b, completion_condition, init.handler)(
+        d, offset, b, completion_condition, init.completion_handler)(
           asio::error_code(), 0, 1);
 
   return init.result.get();
@@ -788,20 +618,20 @@ async_read_at(AsyncRandomAccessReadDevice& d,
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
     detail::transfer_all_t, ASIO_HANDLER_TYPE(ReadHandler,
       void (asio::error_code, std::size_t))>(
-        d, offset, b, transfer_all(), init.handler)(
+        d, offset, b, transfer_all(), init.completion_handler)(
           asio::error_code(), 0, 1);
 
   return init.result.get();
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 } // namespace asio
 
diff --git a/extern/include/asio/impl/read_until.hpp b/extern/include/asio/impl/read_until.hpp
index 763762db..1f39e193 100644
--- a/extern/include/asio/impl/read_until.hpp
+++ b/extern/include/asio/impl/read_until.hpp
@@ -2,7 +2,7 @@
 // impl/read_until.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,8 @@
 #include <string>
 #include <vector>
 #include <utility>
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/buffer.hpp"
 #include "asio/buffers_iterator.hpp"
 #include "asio/detail/bind_handler.hpp"
@@ -33,32 +35,35 @@
 
 namespace asio {
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers, char delim)
 {
   asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, delim, ec);
+  std::size_t bytes_transferred = read_until(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers), delim, ec);
   asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim,
-    asio::error_code& ec)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    char delim, asio::error_code& ec)
 {
+  typename decay<DynamicBuffer>::type b(
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     iterator iter = std::find(start_pos, end, delim);
@@ -82,19 +87,23 @@ std::size_t read_until(SyncReadStream& s,
     }
 
     // Need more data.
-    std::size_t bytes_to_read = read_size_helper(b, 65536);
+    std::size_t bytes_to_read = std::min<std::size_t>(
+          std::max<std::size_t>(512, b.capacity() - b.size()),
+          std::min<std::size_t>(65536, b.max_size() - b.size()));
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const std::string& delim)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_STRING_VIEW_PARAM delim)
 {
   asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, delim, ec);
+  std::size_t bytes_transferred = read_until(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers), delim, ec);
   asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
@@ -134,22 +143,24 @@ namespace detail
   }
 } // namespace detail
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const std::string& delim,
-    asio::error_code& ec)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec)
 {
+  typename decay<DynamicBuffer>::type b(
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     std::pair<iterator, bool> result = detail::partial_search(
@@ -182,41 +193,48 @@ std::size_t read_until(SyncReadStream& s,
     }
 
     // Need more data.
-    std::size_t bytes_to_read = read_size_helper(b, 65536);
+    std::size_t bytes_to_read = std::min<std::size_t>(
+          std::max<std::size_t>(512, b.capacity() - b.size()),
+          std::min<std::size_t>(65536, b.max_size() - b.size()));
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if defined(ASIO_HAS_BOOST_REGEX)
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr)
 {
   asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, expr, ec);
+  std::size_t bytes_transferred = read_until(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers), expr, ec);
   asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    asio::error_code& ec)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr, asio::error_code& ec)
 {
+  typename decay<DynamicBuffer>::type b(
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     boost::match_results<iterator,
@@ -260,23 +278,41 @@ std::size_t read_until(SyncReadStream& s,
 
 #endif // defined(ASIO_HAS_BOOST_REGEX)
 
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
+template <typename SyncReadStream,
+    typename DynamicBuffer, typename MatchCondition>
+inline std::size_t read_until(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    MatchCondition match_condition,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
+{
+  asio::error_code ec;
+  std::size_t bytes_transferred = read_until(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      match_condition, ec);
+  asio::detail::throw_error(ec, "read_until");
+  return bytes_transferred;
+}
+
+template <typename SyncReadStream,
+    typename DynamicBuffer, typename MatchCondition>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
     MatchCondition match_condition, asio::error_code& ec,
     typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
+  typename decay<DynamicBuffer>::type b(
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     std::pair<iterator, bool> result = match_condition(start_pos, end);
@@ -305,35 +341,100 @@ std::size_t read_until(SyncReadStream& s,
     }
 
     // Need more data.
-    std::size_t bytes_to_read = read_size_helper(b, 65536);
+    std::size_t bytes_to_read = std::min<std::size_t>(
+          std::max<std::size_t>(512, b.capacity() - b.size()),
+          std::min<std::size_t>(65536, b.max_size() - b.size()));
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
+#if !defined(ASIO_NO_IOSTREAM)
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, char delim)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, char delim,
+    asio::error_code& ec)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    ASIO_STRING_VIEW_PARAM delim)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
+}
+
+#if defined(ASIO_HAS_BOOST_REGEX)
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), expr);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    asio::error_code& ec)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), expr, ec);
+}
+
+#endif // defined(ASIO_HAS_BOOST_REGEX)
+
 template <typename SyncReadStream, typename Allocator, typename MatchCondition>
 inline std::size_t read_until(SyncReadStream& s,
     asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
     typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, match_condition, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
+  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition);
+}
+
+template <typename SyncReadStream, typename Allocator, typename MatchCondition>
+inline std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    MatchCondition match_condition, asio::error_code& ec,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition, ec);
 }
 
+#endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   class read_until_delim_op
   {
   public:
+    template <typename BufferSequence>
     read_until_delim_op(AsyncReadStream& stream,
-        asio::basic_streambuf<Allocator>& streambuf,
+        ASIO_MOVE_ARG(BufferSequence) buffers,
         char delim, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
         search_position_(0),
@@ -344,7 +445,7 @@ namespace detail
 #if defined(ASIO_HAS_MOVE)
     read_until_delim_op(const read_until_delim_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -354,7 +455,7 @@ namespace detail
 
     read_until_delim_op(read_until_delim_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         delim_(other.delim_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -375,13 +476,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             iterator iter = std::find(start_pos, end, delim_);
@@ -393,7 +494,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -404,7 +505,11 @@ namespace detail
             {
               // Next search can start with the new data.
               search_position_ = end - begin;
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -413,10 +518,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               ASIO_MOVE_CAST(read_until_delim_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -435,97 +540,143 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     char delim_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline bool asio_handler_is_continuation(
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : asio_handler_cont_helpers::is_continuation(
           this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_delim_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_delim_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_delim_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_delim_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    char delim, 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.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   detail::read_until_delim_op<AsyncReadStream,
-    Allocator, ASIO_HANDLER_TYPE(ReadHandler,
-      void (asio::error_code, std::size_t))>(
-        s, b, delim, init.handler)(
-          asio::error_code(), 0, 1);
+    typename decay<DynamicBuffer>::type,
+      ASIO_HANDLER_TYPE(ReadHandler,
+        void (asio::error_code, std::size_t))>(
+          s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            delim, init.completion_handler)(asio::error_code(), 0, 1);
 
   return init.result.get();
 }
 
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   class read_until_delim_string_op
   {
   public:
+    template <typename BufferSequence>
     read_until_delim_string_op(AsyncReadStream& stream,
-        asio::basic_streambuf<Allocator>& streambuf,
+        ASIO_MOVE_ARG(BufferSequence) buffers,
         const std::string& delim, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
         search_position_(0),
@@ -536,7 +687,7 @@ namespace detail
 #if defined(ASIO_HAS_MOVE)
     read_until_delim_string_op(const read_until_delim_string_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -546,7 +697,7 @@ namespace detail
 
     read_until_delim_string_op(read_until_delim_string_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         delim_(ASIO_MOVE_CAST(std::string)(other.delim_)),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -567,13 +718,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             std::pair<iterator, bool> result = detail::partial_search(
@@ -586,7 +737,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -607,7 +758,11 @@ namespace detail
                 search_position_ = end - begin;
               }
 
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -616,10 +771,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               ASIO_MOVE_CAST(read_until_delim_string_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -638,35 +793,38 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     std::string delim_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline bool asio_handler_is_continuation(
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : asio_handler_cont_helpers::is_continuation(
@@ -674,64 +832,109 @@ namespace detail
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename ReadHandler>
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename ReadHandler>
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_delim_string_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_delim_string_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_delim_string_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_delim_string_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const std::string& delim,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_STRING_VIEW_PARAM delim,
     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.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   detail::read_until_delim_string_op<AsyncReadStream,
-    Allocator, ASIO_HANDLER_TYPE(ReadHandler,
-      void (asio::error_code, std::size_t))>(
-        s, b, delim, init.handler)(
-          asio::error_code(), 0, 1);
+    typename decay<DynamicBuffer>::type,
+      ASIO_HANDLER_TYPE(ReadHandler,
+        void (asio::error_code, std::size_t))>(
+          s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            static_cast<std::string>(delim),
+              init.completion_handler)(asio::error_code(), 0, 1);
 
   return init.result.get();
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if defined(ASIO_HAS_BOOST_REGEX)
 
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   class read_until_expr_op
   {
   public:
+    template <typename BufferSequence>
     read_until_expr_op(AsyncReadStream& stream,
-        asio::basic_streambuf<Allocator>& streambuf,
+        ASIO_MOVE_ARG(BufferSequence) buffers,
         const boost::regex& expr, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),
         expr_(expr),
         start_(0),
         search_position_(0),
@@ -742,7 +945,7 @@ namespace detail
 #if defined(ASIO_HAS_MOVE)
     read_until_expr_op(const read_until_expr_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         expr_(other.expr_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -752,7 +955,7 @@ namespace detail
 
     read_until_expr_op(read_until_expr_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         expr_(other.expr_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -773,13 +976,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             boost::match_results<iterator,
@@ -795,7 +998,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -816,7 +1019,11 @@ namespace detail
                 search_position_ = end - begin;
               }
 
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -825,10 +1032,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               ASIO_MOVE_CAST(read_until_expr_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -847,85 +1054,127 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     RegEx expr_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   inline bool asio_handler_is_continuation(
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : asio_handler_cont_helpers::is_continuation(
           this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename RegEx, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename RegEx, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename RegEx, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename RegEx, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename RegEx, typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_expr_op<AsyncReadStream,
+      DynamicBuffer, RegEx, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_expr_op<AsyncReadStream,
+        DynamicBuffer, RegEx, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename RegEx, typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_expr_op<AsyncReadStream,
+      DynamicBuffer, RegEx, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_expr_op<AsyncReadStream,
+        DynamicBuffer, RegEx, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr,
     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.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::read_until_expr_op<AsyncReadStream, Allocator,
-    boost::regex, ASIO_HANDLER_TYPE(ReadHandler,
-      void (asio::error_code, std::size_t))>(
-        s, b, expr, init.handler)(
-          asio::error_code(), 0, 1);
+  detail::read_until_expr_op<AsyncReadStream,
+    typename decay<DynamicBuffer>::type,
+      boost::regex, ASIO_HANDLER_TYPE(ReadHandler,
+        void (asio::error_code, std::size_t))>(
+          s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            expr, init.completion_handler)(asio::error_code(), 0, 1);
 
   return init.result.get();
 }
@@ -934,16 +1183,17 @@ async_read_until(AsyncReadStream& s,
 
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   class read_until_match_op
   {
   public:
+    template <typename BufferSequence>
     read_until_match_op(AsyncReadStream& stream,
-        asio::basic_streambuf<Allocator>& streambuf,
+        ASIO_MOVE_ARG(BufferSequence) buffers,
         MatchCondition match_condition, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),
         match_condition_(match_condition),
         start_(0),
         search_position_(0),
@@ -954,7 +1204,7 @@ namespace detail
 #if defined(ASIO_HAS_MOVE)
     read_until_match_op(const read_until_match_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         match_condition_(other.match_condition_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -964,7 +1214,7 @@ namespace detail
 
     read_until_match_op(read_until_match_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         match_condition_(other.match_condition_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -985,13 +1235,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             std::pair<iterator, bool> result = match_condition_(start_pos, end);
@@ -1003,7 +1253,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -1024,7 +1274,11 @@ namespace detail
                 search_position_ = end - begin;
               }
 
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -1033,10 +1287,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               ASIO_MOVE_CAST(read_until_match_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -1055,71 +1309,113 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     MatchCondition match_condition_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   inline bool asio_handler_is_continuation(
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : asio_handler_cont_helpers::is_continuation(
           this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename MatchCondition, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename MatchCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename MatchCondition, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename MatchCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+      MatchCondition, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator,
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename MatchCondition, typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_match_op<AsyncReadStream,
+      DynamicBuffer, MatchCondition, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_match_op<AsyncReadStream,
+        DynamicBuffer, MatchCondition, ReadHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename MatchCondition, typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_match_op<AsyncReadStream,
+      DynamicBuffer, MatchCondition, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_match_op<AsyncReadStream,
+        DynamicBuffer, MatchCondition, ReadHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
     typename MatchCondition, typename ReadHandler>
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
     MatchCondition match_condition, ASIO_MOVE_ARG(ReadHandler) handler,
     typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
@@ -1127,19 +1423,76 @@ async_read_until(AsyncReadStream& s,
   // not meet the documented type requirements for a ReadHandler.
   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::read_until_match_op<AsyncReadStream, Allocator,
-    MatchCondition, ASIO_HANDLER_TYPE(ReadHandler,
-      void (asio::error_code, std::size_t))>(
-        s, b, match_condition, init.handler)(
-          asio::error_code(), 0, 1);
+  detail::read_until_match_op<AsyncReadStream,
+    typename decay<DynamicBuffer>::type,
+      MatchCondition, ASIO_HANDLER_TYPE(ReadHandler,
+        void (asio::error_code, std::size_t))>(
+          s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            match_condition, init.completion_handler)(
+              asio::error_code(), 0, 1);
 
   return init.result.get();
 }
 
+#if !defined(ASIO_NO_IOSTREAM)
+
+template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    char delim, ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      delim, ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    ASIO_STRING_VIEW_PARAM delim,
+    ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      delim, ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+#if defined(ASIO_HAS_BOOST_REGEX)
+
+template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      expr, ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+#endif // defined(ASIO_HAS_BOOST_REGEX)
+
+template <typename AsyncReadStream, typename Allocator,
+    typename MatchCondition, typename ReadHandler>
+inline ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    MatchCondition match_condition, ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      match_condition, ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
diff --git a/extern/include/asio/impl/serial_port_base.hpp b/extern/include/asio/impl/serial_port_base.hpp
index abb8cdec..cdc201d8 100644
--- a/extern/include/asio/impl/serial_port_base.hpp
+++ b/extern/include/asio/impl/serial_port_base.hpp
@@ -2,7 +2,7 @@
 // impl/serial_port_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/extern/include/asio/impl/serial_port_base.ipp b/extern/include/asio/impl/serial_port_base.ipp
index 57306d92..5d52ed59 100644
--- a/extern/include/asio/impl/serial_port_base.ipp
+++ b/extern/include/asio/impl/serial_port_base.ipp
@@ -2,7 +2,7 @@
 // impl/serial_port_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -37,7 +37,7 @@
 
 namespace asio {
 
-asio::error_code serial_port_base::baud_rate::store(
+ASIO_SYNC_OP_VOID serial_port_base::baud_rate::store(
     ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -111,9 +111,9 @@ asio::error_code serial_port_base::baud_rate::store(
 # endif
   default:
     ec = asio::error::invalid_argument;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
-# if defined(_BSD_SOURCE)
+# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
   ::cfsetspeed(&storage, baud);
 # else
   ::cfsetispeed(&storage, baud);
@@ -121,10 +121,10 @@ asio::error_code serial_port_base::baud_rate::store(
 # endif
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code serial_port_base::baud_rate::load(
+ASIO_SYNC_OP_VOID serial_port_base::baud_rate::load(
     const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -199,11 +199,11 @@ asio::error_code serial_port_base::baud_rate::load(
   default:
     value_ = 0;
     ec = asio::error::invalid_argument;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 serial_port_base::flow_control::flow_control(
@@ -217,7 +217,7 @@ serial_port_base::flow_control::flow_control(
   }
 }
 
-asio::error_code serial_port_base::flow_control::store(
+ASIO_SYNC_OP_VOID serial_port_base::flow_control::store(
     ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -249,7 +249,7 @@ asio::error_code serial_port_base::flow_control::store(
   {
   case none:
     storage.c_iflag &= ~(IXOFF | IXON);
-# if defined(_BSD_SOURCE)
+# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
     storage.c_cflag &= ~CRTSCTS;
 # elif defined(__QNXNTO__)
     storage.c_cflag &= ~(IHFLOW | OHFLOW);
@@ -257,14 +257,14 @@ asio::error_code serial_port_base::flow_control::store(
     break;
   case software:
     storage.c_iflag |= IXOFF | IXON;
-# if defined(_BSD_SOURCE)
+# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
     storage.c_cflag &= ~CRTSCTS;
 # elif defined(__QNXNTO__)
     storage.c_cflag &= ~(IHFLOW | OHFLOW);
 # endif
     break;
   case hardware:
-# if defined(_BSD_SOURCE)
+# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
     storage.c_iflag &= ~(IXOFF | IXON);
     storage.c_cflag |= CRTSCTS;
     break;
@@ -274,17 +274,17 @@ asio::error_code serial_port_base::flow_control::store(
     break;
 # else
     ec = asio::error::operation_not_supported;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
 # endif
   default:
     break;
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code serial_port_base::flow_control::load(
+ASIO_SYNC_OP_VOID serial_port_base::flow_control::load(
     const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -305,7 +305,7 @@ asio::error_code serial_port_base::flow_control::load(
   {
     value_ = software;
   }
-# if defined(_BSD_SOURCE)
+# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
   else if (storage.c_cflag & CRTSCTS)
   {
     value_ = hardware;
@@ -322,7 +322,7 @@ asio::error_code serial_port_base::flow_control::load(
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 serial_port_base::parity::parity(serial_port_base::parity::type t)
@@ -335,7 +335,7 @@ serial_port_base::parity::parity(serial_port_base::parity::type t)
   }
 }
 
-asio::error_code serial_port_base::parity::store(
+ASIO_SYNC_OP_VOID serial_port_base::parity::store(
     ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -379,10 +379,10 @@ asio::error_code serial_port_base::parity::store(
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code serial_port_base::parity::load(
+ASIO_SYNC_OP_VOID serial_port_base::parity::load(
     const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -416,7 +416,7 @@ asio::error_code serial_port_base::parity::load(
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 serial_port_base::stop_bits::stop_bits(
@@ -430,7 +430,7 @@ serial_port_base::stop_bits::stop_bits(
   }
 }
 
-asio::error_code serial_port_base::stop_bits::store(
+ASIO_SYNC_OP_VOID serial_port_base::stop_bits::store(
     ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -459,14 +459,14 @@ asio::error_code serial_port_base::stop_bits::store(
     break;
   default:
     ec = asio::error::operation_not_supported;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code serial_port_base::stop_bits::load(
+ASIO_SYNC_OP_VOID serial_port_base::stop_bits::load(
     const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -490,7 +490,7 @@ asio::error_code serial_port_base::stop_bits::load(
   value_ = (storage.c_cflag & CSTOPB) ? two : one;
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 serial_port_base::character_size::character_size(unsigned int t)
@@ -503,7 +503,7 @@ serial_port_base::character_size::character_size(unsigned int t)
   }
 }
 
-asio::error_code serial_port_base::character_size::store(
+ASIO_SYNC_OP_VOID serial_port_base::character_size::store(
     ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -520,10 +520,10 @@ asio::error_code serial_port_base::character_size::store(
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code serial_port_base::character_size::load(
+ASIO_SYNC_OP_VOID serial_port_base::character_size::load(
     const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -540,7 +540,7 @@ asio::error_code serial_port_base::character_size::load(
   }
 #endif
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 } // namespace asio
diff --git a/extern/include/asio/impl/spawn.hpp b/extern/include/asio/impl/spawn.hpp
index 170fdf3e..5594ad93 100644
--- a/extern/include/asio/impl/spawn.hpp
+++ b/extern/include/asio/impl/spawn.hpp
@@ -2,7 +2,7 @@
 // impl/spawn.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,14 +16,18 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/async_result.hpp"
+#include "asio/bind_executor.hpp"
 #include "asio/detail/atomic_count.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
-#include "asio/detail/shared_ptr.hpp"
-#include "asio/handler_type.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/system_error.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -63,7 +67,7 @@ namespace detail {
   //private:
     shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
     typename basic_yield_context<Handler>::caller_type& ca_;
-    Handler& handler_;
+    Handler handler_;
     atomic_count* ready_;
     asio::error_code* ec_;
     T* value_;
@@ -99,7 +103,7 @@ namespace detail {
   //private:
     shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
     typename basic_yield_context<Handler>::caller_type& ca_;
-    Handler& handler_;
+    Handler handler_;
     atomic_count* ready_;
     asio::error_code* ec_;
   };
@@ -142,10 +146,139 @@ namespace detail {
         function, this_handler->handler_);
   }
 
+  template <typename Handler, typename T>
+  class coro_async_result
+  {
+  public:
+    typedef coro_handler<Handler, T> completion_handler_type;
+    typedef T return_type;
+
+    explicit coro_async_result(completion_handler_type& h)
+      : handler_(h),
+        ca_(h.ca_),
+        ready_(2)
+    {
+      h.ready_ = &ready_;
+      out_ec_ = h.ec_;
+      if (!out_ec_) h.ec_ = &ec_;
+      h.value_ = &value_;
+    }
+
+    return_type get()
+    {
+      // Must not hold shared_ptr to coro while suspended.
+      handler_.coro_.reset();
+
+      if (--ready_ != 0)
+        ca_();
+      if (!out_ec_ && ec_) throw asio::system_error(ec_);
+      return ASIO_MOVE_CAST(return_type)(value_);
+    }
+
+  private:
+    completion_handler_type& handler_;
+    typename basic_yield_context<Handler>::caller_type& ca_;
+    atomic_count ready_;
+    asio::error_code* out_ec_;
+    asio::error_code ec_;
+    return_type value_;
+  };
+
+  template <typename Handler>
+  class coro_async_result<Handler, void>
+  {
+  public:
+    typedef coro_handler<Handler, void> completion_handler_type;
+    typedef void return_type;
+
+    explicit coro_async_result(completion_handler_type& h)
+      : handler_(h),
+        ca_(h.ca_),
+        ready_(2)
+    {
+      h.ready_ = &ready_;
+      out_ec_ = h.ec_;
+      if (!out_ec_) h.ec_ = &ec_;
+    }
+
+    void get()
+    {
+      // Must not hold shared_ptr to coro while suspended.
+      handler_.coro_.reset();
+
+      if (--ready_ != 0)
+        ca_();
+      if (!out_ec_ && ec_) throw asio::system_error(ec_);
+    }
+
+  private:
+    completion_handler_type& handler_;
+    typename basic_yield_context<Handler>::caller_type& ca_;
+    atomic_count ready_;
+    asio::error_code* out_ec_;
+    asio::error_code ec_;
+  };
+
 } // namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
+template <typename Handler, typename ReturnType>
+class async_result<basic_yield_context<Handler>, ReturnType()>
+  : public detail::coro_async_result<Handler, void>
+{
+public:
+  explicit async_result(
+    typename detail::coro_async_result<Handler,
+      void>::completion_handler_type& h)
+    : detail::coro_async_result<Handler, void>(h)
+  {
+  }
+};
+
+template <typename Handler, typename ReturnType, typename Arg1>
+class async_result<basic_yield_context<Handler>, ReturnType(Arg1)>
+  : public detail::coro_async_result<Handler, typename decay<Arg1>::type>
+{
+public:
+  explicit async_result(
+    typename detail::coro_async_result<Handler,
+      typename decay<Arg1>::type>::completion_handler_type& h)
+    : detail::coro_async_result<Handler, typename decay<Arg1>::type>(h)
+  {
+  }
+};
+
+template <typename Handler, typename ReturnType>
+class async_result<basic_yield_context<Handler>,
+    ReturnType(asio::error_code)>
+  : public detail::coro_async_result<Handler, void>
+{
+public:
+  explicit async_result(
+    typename detail::coro_async_result<Handler,
+      void>::completion_handler_type& h)
+    : detail::coro_async_result<Handler, void>(h)
+  {
+  }
+};
+
+template <typename Handler, typename ReturnType, typename Arg2>
+class async_result<basic_yield_context<Handler>,
+    ReturnType(asio::error_code, Arg2)>
+  : public detail::coro_async_result<Handler, typename decay<Arg2>::type>
+{
+public:
+  explicit async_result(
+    typename detail::coro_async_result<Handler,
+      typename decay<Arg2>::type>::completion_handler_type& h)
+    : detail::coro_async_result<Handler, typename decay<Arg2>::type>(h)
+  {
+  }
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
+
 template <typename Handler, typename ReturnType>
 struct handler_type<basic_yield_context<Handler>, ReturnType()>
 {
@@ -155,7 +288,7 @@ struct handler_type<basic_yield_context<Handler>, ReturnType()>
 template <typename Handler, typename ReturnType, typename Arg1>
 struct handler_type<basic_yield_context<Handler>, ReturnType(Arg1)>
 {
-  typedef detail::coro_handler<Handler, Arg1> type;
+  typedef detail::coro_handler<Handler, typename decay<Arg1>::type> type;
 };
 
 template <typename Handler, typename ReturnType>
@@ -169,74 +302,48 @@ template <typename Handler, typename ReturnType, typename Arg2>
 struct handler_type<basic_yield_context<Handler>,
     ReturnType(asio::error_code, Arg2)>
 {
-  typedef detail::coro_handler<Handler, Arg2> type;
+  typedef detail::coro_handler<Handler, typename decay<Arg2>::type> type;
 };
 
 template <typename Handler, typename T>
 class async_result<detail::coro_handler<Handler, T> >
+  : public detail::coro_async_result<Handler, T>
 {
 public:
-  typedef T type;
-
-  explicit async_result(detail::coro_handler<Handler, T>& h)
-    : handler_(h),
-      ca_(h.ca_),
-      ready_(2)
-  {
-    h.ready_ = &ready_;
-    out_ec_ = h.ec_;
-    if (!out_ec_) h.ec_ = &ec_;
-    h.value_ = &value_;
-  }
+  typedef typename detail::coro_async_result<Handler, T>::return_type type;
 
-  type get()
+  explicit async_result(
+    typename detail::coro_async_result<Handler,
+      T>::completion_handler_type& h)
+    : detail::coro_async_result<Handler, T>(h)
   {
-    handler_.coro_.reset(); // Must not hold shared_ptr to coro while suspended.
-    if (--ready_ != 0)
-      ca_();
-    if (!out_ec_ && ec_) throw asio::system_error(ec_);
-    return ASIO_MOVE_CAST(type)(value_);
   }
-
-private:
-  detail::coro_handler<Handler, T>& handler_;
-  typename basic_yield_context<Handler>::caller_type& ca_;
-  detail::atomic_count ready_;
-  asio::error_code* out_ec_;
-  asio::error_code ec_;
-  type value_;
 };
 
-template <typename Handler>
-class async_result<detail::coro_handler<Handler, void> >
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+template <typename Handler, typename T, typename Allocator>
+struct associated_allocator<detail::coro_handler<Handler, T>, Allocator>
 {
-public:
-  typedef void type;
+  typedef typename associated_allocator<Handler, Allocator>::type type;
 
-  explicit async_result(detail::coro_handler<Handler, void>& h)
-    : handler_(h),
-      ca_(h.ca_),
-      ready_(2)
+  static type get(const detail::coro_handler<Handler, T>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
   {
-    h.ready_ = &ready_;
-    out_ec_ = h.ec_;
-    if (!out_ec_) h.ec_ = &ec_;
+    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
   }
+};
+
+template <typename Handler, typename T, typename Executor>
+struct associated_executor<detail::coro_handler<Handler, T>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
 
-  void get()
+  static type get(const detail::coro_handler<Handler, T>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
   {
-    handler_.coro_.reset(); // Must not hold shared_ptr to coro while suspended.
-    if (--ready_ != 0)
-      ca_();
-    if (!out_ec_ && ec_) throw asio::system_error(ec_);
+    return associated_executor<Handler, Executor>::get(h.handler_, ex);
   }
-
-private:
-  detail::coro_handler<Handler, void>& handler_;
-  typename basic_yield_context<Handler>::caller_type& ca_;
-  detail::atomic_count ready_;
-  asio::error_code* out_ec_;
-  asio::error_code ec_;
 };
 
 namespace detail {
@@ -244,11 +351,12 @@ namespace detail {
   template <typename Handler, typename Function>
   struct spawn_data : private noncopyable
   {
-    spawn_data(ASIO_MOVE_ARG(Handler) handler,
-        bool call_handler, ASIO_MOVE_ARG(Function) function)
-      : handler_(ASIO_MOVE_CAST(Handler)(handler)),
+    template <typename Hand, typename Func>
+    spawn_data(ASIO_MOVE_ARG(Hand) handler,
+        bool call_handler, ASIO_MOVE_ARG(Func) function)
+      : handler_(ASIO_MOVE_CAST(Hand)(handler)),
         call_handler_(call_handler),
-        function_(ASIO_MOVE_CAST(Function)(function))
+        function_(ASIO_MOVE_CAST(Func)(function))
     {
     }
 
@@ -269,6 +377,7 @@ namespace detail {
 #endif // !defined(BOOST_COROUTINES_UNIDIRECT) && !defined(BOOST_COROUTINES_V2)
       const basic_yield_context<Handler> yield(
           data->coro_, ca, data->handler_);
+
       (data->function_)(yield);
       if (data->call_handler_)
         (data->handler_)();
@@ -293,22 +402,62 @@ namespace detail {
     boost::coroutines::attributes attributes_;
   };
 
+  template <typename Function, typename Handler, typename Function1>
+  inline void asio_handler_invoke(Function& function,
+      spawn_helper<Handler, Function1>* this_handler)
+  {
+    asio_handler_invoke_helpers::invoke(
+        function, this_handler->data_->handler_);
+  }
+
+  template <typename Function, typename Handler, typename Function1>
+  inline void asio_handler_invoke(const Function& function,
+      spawn_helper<Handler, Function1>* this_handler)
+  {
+    asio_handler_invoke_helpers::invoke(
+        function, this_handler->data_->handler_);
+  }
+
   inline void default_spawn_handler() {}
 
 } // namespace detail
 
+template <typename Function>
+inline void spawn(ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes)
+{
+  typedef typename decay<Function>::type function_type;
+
+  typename associated_executor<function_type>::type ex(
+      (get_associated_executor)(function));
+
+  asio::spawn(ex, ASIO_MOVE_CAST(Function)(function), attributes);
+}
+
 template <typename Handler, typename Function>
 void spawn(ASIO_MOVE_ARG(Handler) handler,
     ASIO_MOVE_ARG(Function) function,
-    const boost::coroutines::attributes& attributes)
+    const boost::coroutines::attributes& attributes,
+    typename enable_if<!is_executor<typename decay<Handler>::type>::value &&
+      !is_convertible<Handler&, execution_context&>::value>::type*)
 {
-  detail::spawn_helper<Handler, Function> helper;
+  typedef typename decay<Handler>::type handler_type;
+  typedef typename decay<Function>::type function_type;
+
+  typename associated_executor<handler_type>::type ex(
+      (get_associated_executor)(handler));
+
+  typename associated_allocator<handler_type>::type a(
+      (get_associated_allocator)(handler));
+
+  detail::spawn_helper<handler_type, function_type> helper;
   helper.data_.reset(
-      new detail::spawn_data<Handler, Function>(
+      new detail::spawn_data<handler_type, function_type>(
         ASIO_MOVE_CAST(Handler)(handler), true,
         ASIO_MOVE_CAST(Function)(function)));
   helper.attributes_ = attributes;
-  asio_handler_invoke_helpers::invoke(helper, helper.data_->handler_);
+
+  ex.dispatch(helper, a);
 }
 
 template <typename Handler, typename Function>
@@ -316,31 +465,64 @@ void spawn(basic_yield_context<Handler> ctx,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes)
 {
+  typedef typename decay<Function>::type function_type;
+
   Handler handler(ctx.handler_); // Explicit copy that might be moved from.
-  detail::spawn_helper<Handler, Function> helper;
+
+  typename associated_executor<Handler>::type ex(
+      (get_associated_executor)(handler));
+
+  typename associated_allocator<Handler>::type a(
+      (get_associated_allocator)(handler));
+
+  detail::spawn_helper<Handler, function_type> helper;
   helper.data_.reset(
-      new detail::spawn_data<Handler, Function>(
+      new detail::spawn_data<Handler, function_type>(
         ASIO_MOVE_CAST(Handler)(handler), false,
         ASIO_MOVE_CAST(Function)(function)));
   helper.attributes_ = attributes;
-  asio_handler_invoke_helpers::invoke(helper, helper.data_->handler_);
+
+  ex.dispatch(helper, a);
 }
 
-template <typename Function>
-void spawn(asio::io_service::strand strand,
+template <typename Function, typename Executor>
+inline void spawn(const Executor& ex,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes,
+    typename enable_if<is_executor<Executor>::value>::type*)
+{
+  asio::spawn(asio::strand<Executor>(ex),
+      ASIO_MOVE_CAST(Function)(function), attributes);
+}
+
+template <typename Function, typename Executor>
+inline void spawn(const strand<Executor>& ex,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes)
 {
-  asio::spawn(strand.wrap(&detail::default_spawn_handler),
+  asio::spawn(asio::bind_executor(
+        ex, &detail::default_spawn_handler),
       ASIO_MOVE_CAST(Function)(function), attributes);
 }
 
 template <typename Function>
-void spawn(asio::io_service& io_service,
+inline void spawn(const asio::io_context::strand& s,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes)
 {
-  asio::spawn(asio::io_service::strand(io_service),
+  asio::spawn(asio::bind_executor(
+        s, &detail::default_spawn_handler),
+      ASIO_MOVE_CAST(Function)(function), attributes);
+}
+
+template <typename Function, typename ExecutionContext>
+inline void spawn(ExecutionContext& ctx,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type*)
+{
+  asio::spawn(ctx.get_executor(),
       ASIO_MOVE_CAST(Function)(function), attributes);
 }
 
diff --git a/extern/include/asio/impl/src.cpp b/extern/include/asio/impl/src.cpp
index bcd882f2..e8a5953d 100644
--- a/extern/include/asio/impl/src.cpp
+++ b/extern/include/asio/impl/src.cpp
@@ -2,7 +2,7 @@
 // impl/src.cpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/impl/src.hpp b/extern/include/asio/impl/src.hpp
index 7e940cb5..a72637b9 100644
--- a/extern/include/asio/impl/src.hpp
+++ b/extern/include/asio/impl/src.hpp
@@ -2,7 +2,7 @@
 // impl/src.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,9 +21,13 @@
 
 #include "asio/impl/error.ipp"
 #include "asio/impl/error_code.ipp"
+#include "asio/impl/execution_context.ipp"
+#include "asio/impl/executor.ipp"
 #include "asio/impl/handler_alloc_hook.ipp"
-#include "asio/impl/io_service.ipp"
+#include "asio/impl/io_context.ipp"
 #include "asio/impl/serial_port_base.ipp"
+#include "asio/impl/system_context.ipp"
+#include "asio/impl/thread_pool.ipp"
 #include "asio/detail/impl/buffer_sequence_adapter.ipp"
 #include "asio/detail/impl/descriptor_ops.ipp"
 #include "asio/detail/impl/dev_poll_reactor.ipp"
@@ -31,6 +35,7 @@
 #include "asio/detail/impl/eventfd_select_interrupter.ipp"
 #include "asio/detail/impl/handler_tracking.ipp"
 #include "asio/detail/impl/kqueue_reactor.ipp"
+#include "asio/detail/impl/null_event.ipp"
 #include "asio/detail/impl/pipe_select_interrupter.ipp"
 #include "asio/detail/impl/posix_event.ipp"
 #include "asio/detail/impl/posix_mutex.ipp"
@@ -40,18 +45,19 @@
 #include "asio/detail/impl/reactive_serial_port_service.ipp"
 #include "asio/detail/impl/reactive_socket_service_base.ipp"
 #include "asio/detail/impl/resolver_service_base.ipp"
+#include "asio/detail/impl/scheduler.ipp"
 #include "asio/detail/impl/select_reactor.ipp"
 #include "asio/detail/impl/service_registry.ipp"
 #include "asio/detail/impl/signal_set_service.ipp"
 #include "asio/detail/impl/socket_ops.ipp"
 #include "asio/detail/impl/socket_select_interrupter.ipp"
+#include "asio/detail/impl/strand_executor_service.ipp"
 #include "asio/detail/impl/strand_service.ipp"
-#include "asio/detail/impl/task_io_service.ipp"
 #include "asio/detail/impl/throw_error.ipp"
 #include "asio/detail/impl/timer_queue_ptime.ipp"
 #include "asio/detail/impl/timer_queue_set.ipp"
 #include "asio/detail/impl/win_iocp_handle_service.ipp"
-#include "asio/detail/impl/win_iocp_io_service.ipp"
+#include "asio/detail/impl/win_iocp_io_context.ipp"
 #include "asio/detail/impl/win_iocp_serial_port_service.ipp"
 #include "asio/detail/impl/win_iocp_socket_service_base.ipp"
 #include "asio/detail/impl/win_event.ipp"
@@ -68,6 +74,8 @@
 #include "asio/ip/impl/address_v4.ipp"
 #include "asio/ip/impl/address_v6.ipp"
 #include "asio/ip/impl/host_name.ipp"
+#include "asio/ip/impl/network_v4.ipp"
+#include "asio/ip/impl/network_v6.ipp"
 #include "asio/ip/detail/impl/endpoint.ipp"
 #include "asio/local/detail/impl/endpoint.ipp"
 
diff --git a/extern/include/asio/impl/system_context.hpp b/extern/include/asio/impl/system_context.hpp
new file mode 100644
index 00000000..87ffe76a
--- /dev/null
+++ b/extern/include/asio/impl/system_context.hpp
@@ -0,0 +1,34 @@
+//
+// impl/system_context.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_SYSTEM_CONTEXT_HPP
+#define ASIO_IMPL_SYSTEM_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/system_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+inline system_context::executor_type
+system_context::get_executor() ASIO_NOEXCEPT
+{
+  return system_executor();
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_SYSTEM_CONTEXT_HPP
diff --git a/extern/include/asio/impl/system_context.ipp b/extern/include/asio/impl/system_context.ipp
new file mode 100644
index 00000000..8ad5e418
--- /dev/null
+++ b/extern/include/asio/impl/system_context.ipp
@@ -0,0 +1,73 @@
+//
+// impl/system_context.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_SYSTEM_CONTEXT_IPP
+#define ASIO_IMPL_SYSTEM_CONTEXT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/system_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+struct system_context::thread_function
+{
+  detail::scheduler* scheduler_;
+
+  void operator()()
+  {
+    asio::error_code ec;
+    scheduler_->run(ec);
+  }
+};
+
+system_context::system_context()
+  : scheduler_(use_service<detail::scheduler>(*this))
+{
+  scheduler_.work_started();
+
+  thread_function f = { &scheduler_ };
+  std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
+  threads_.create_threads(f, num_threads ? num_threads : 2);
+}
+
+system_context::~system_context()
+{
+  scheduler_.work_finished();
+  scheduler_.stop();
+  threads_.join();
+}
+
+void system_context::stop()
+{
+  scheduler_.stop();
+}
+
+bool system_context::stopped() const ASIO_NOEXCEPT
+{
+  return scheduler_.stopped();
+}
+
+void system_context::join()
+{
+  scheduler_.work_finished();
+  threads_.join();
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_SYSTEM_CONTEXT_IPP
diff --git a/extern/include/asio/impl/system_executor.hpp b/extern/include/asio/impl/system_executor.hpp
new file mode 100644
index 00000000..ac4861f5
--- /dev/null
+++ b/extern/include/asio/impl/system_executor.hpp
@@ -0,0 +1,85 @@
+//
+// impl/system_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_SYSTEM_EXECUTOR_HPP
+#define ASIO_IMPL_SYSTEM_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/executor_op.hpp"
+#include "asio/detail/global.hpp"
+#include "asio/detail/recycling_allocator.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/system_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+inline system_context& system_executor::context() const ASIO_NOEXCEPT
+{
+  return detail::global<system_context>();
+}
+
+template <typename Function, typename Allocator>
+void system_executor::dispatch(
+    ASIO_MOVE_ARG(Function) f, const Allocator&) const
+{
+  typename decay<Function>::type tmp(ASIO_MOVE_CAST(Function)(f));
+  asio_handler_invoke_helpers::invoke(tmp, tmp);
+}
+
+template <typename Function, typename Allocator>
+void system_executor::post(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  system_context& ctx = detail::global<system_context>();
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((ctx, *p.p,
+        "system_executor", &this->context(), 0, "post"));
+
+  ctx.scheduler_.post_immediate_completion(p.p, false);
+  p.v = p.p = 0;
+}
+
+template <typename Function, typename Allocator>
+void system_executor::defer(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  system_context& ctx = detail::global<system_context>();
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((ctx, *p.p,
+        "system_executor", &this->context(), 0, "defer"));
+
+  ctx.scheduler_.post_immediate_completion(p.p, true);
+  p.v = p.p = 0;
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_SYSTEM_EXECUTOR_HPP
diff --git a/extern/include/asio/impl/thread_pool.hpp b/extern/include/asio/impl/thread_pool.hpp
new file mode 100644
index 00000000..058e3771
--- /dev/null
+++ b/extern/include/asio/impl/thread_pool.hpp
@@ -0,0 +1,127 @@
+//
+// impl/thread_pool.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_THREAD_POOL_HPP
+#define ASIO_IMPL_THREAD_POOL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/executor_op.hpp"
+#include "asio/detail/fenced_block.hpp"
+#include "asio/detail/recycling_allocator.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+inline thread_pool::executor_type
+thread_pool::get_executor() ASIO_NOEXCEPT
+{
+  return executor_type(*this);
+}
+
+inline thread_pool&
+thread_pool::executor_type::context() const ASIO_NOEXCEPT
+{
+  return pool_;
+}
+
+inline void
+thread_pool::executor_type::on_work_started() const ASIO_NOEXCEPT
+{
+  pool_.scheduler_.work_started();
+}
+
+inline void thread_pool::executor_type::on_work_finished()
+const ASIO_NOEXCEPT
+{
+  pool_.scheduler_.work_finished();
+}
+
+template <typename Function, typename Allocator>
+void thread_pool::executor_type::dispatch(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Invoke immediately if we are already inside the thread pool.
+  if (pool_.scheduler_.can_dispatch())
+  {
+    // Make a local, non-const copy of the function.
+    function_type tmp(ASIO_MOVE_CAST(Function)(f));
+
+    detail::fenced_block b(detail::fenced_block::full);
+    asio_handler_invoke_helpers::invoke(tmp, tmp);
+    return;
+  }
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((pool_, *p.p,
+        "thread_pool", &this->context(), 0, "dispatch"));
+
+  pool_.scheduler_.post_immediate_completion(p.p, false);
+  p.v = p.p = 0;
+}
+
+template <typename Function, typename Allocator>
+void thread_pool::executor_type::post(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((pool_, *p.p,
+        "thread_pool", &this->context(), 0, "post"));
+
+  pool_.scheduler_.post_immediate_completion(p.p, false);
+  p.v = p.p = 0;
+}
+
+template <typename Function, typename Allocator>
+void thread_pool::executor_type::defer(
+    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
+
+  ASIO_HANDLER_CREATION((pool_, *p.p,
+        "thread_pool", &this->context(), 0, "defer"));
+
+  pool_.scheduler_.post_immediate_completion(p.p, true);
+  p.v = p.p = 0;
+}
+
+inline bool
+thread_pool::executor_type::running_in_this_thread() const ASIO_NOEXCEPT
+{
+  return pool_.scheduler_.can_dispatch();
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_THREAD_POOL_HPP
diff --git a/extern/include/asio/impl/thread_pool.ipp b/extern/include/asio/impl/thread_pool.ipp
new file mode 100644
index 00000000..89583c14
--- /dev/null
+++ b/extern/include/asio/impl/thread_pool.ipp
@@ -0,0 +1,76 @@
+//
+// impl/thread_pool.ipp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IMPL_THREAD_POOL_IPP
+#define ASIO_IMPL_THREAD_POOL_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/thread_pool.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+struct thread_pool::thread_function
+{
+  detail::scheduler* scheduler_;
+
+  void operator()()
+  {
+    asio::error_code ec;
+    scheduler_->run(ec);
+  }
+};
+
+thread_pool::thread_pool()
+  : scheduler_(use_service<detail::scheduler>(*this))
+{
+  scheduler_.work_started();
+
+  thread_function f = { &scheduler_ };
+  std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
+  threads_.create_threads(f, num_threads ? num_threads : 2);
+}
+
+thread_pool::thread_pool(std::size_t num_threads)
+  : scheduler_(use_service<detail::scheduler>(*this))
+{
+  scheduler_.work_started();
+
+  thread_function f = { &scheduler_ };
+  threads_.create_threads(f, num_threads);
+}
+
+thread_pool::~thread_pool()
+{
+  stop();
+  join();
+}
+
+void thread_pool::stop()
+{
+  scheduler_.stop();
+}
+
+void thread_pool::join()
+{
+  scheduler_.work_finished();
+  threads_.join();
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMPL_THREAD_POOL_IPP
diff --git a/extern/include/asio/impl/use_future.hpp b/extern/include/asio/impl/use_future.hpp
index fd3857f1..51eb7e2c 100644
--- a/extern/include/asio/impl/use_future.hpp
+++ b/extern/include/asio/impl/use_future.hpp
@@ -2,7 +2,7 @@
 // impl/use_future.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,152 +17,918 @@
 
 #include "asio/detail/config.hpp"
 #include <future>
+#include <tuple>
 #include "asio/async_result.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/error_code.hpp"
-#include "asio/handler_type.hpp"
+#include "asio/packaged_task.hpp"
 #include "asio/system_error.hpp"
+#include "asio/system_executor.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-  // Completion handler to adapt a promise as a completion handler.
-  template <typename T>
-  class promise_handler
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename F, typename... Args>
+inline void promise_invoke_and_set(std::promise<T>& p,
+    F& f, ASIO_MOVE_ARG(Args)... args)
+{
+#if !defined(ASIO_NO_EXCEPTIONS)
+  try
+#endif // !defined(ASIO_NO_EXCEPTIONS)
   {
-  public:
-    // Construct from use_future special value.
-    template <typename Allocator>
-    promise_handler(use_future_t<Allocator> uf)
-      : promise_(std::allocate_shared<std::promise<T> >(
-            uf.get_allocator(), std::allocator_arg, uf.get_allocator()))
-    {
-    }
+    p.set_value(f(ASIO_MOVE_CAST(Args)(args)...));
+  }
+#if !defined(ASIO_NO_EXCEPTIONS)
+  catch (...)
+  {
+    p.set_exception(std::current_exception());
+  }
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+}
+
+template <typename F, typename... Args>
+inline void promise_invoke_and_set(std::promise<void>& p,
+    F& f, ASIO_MOVE_ARG(Args)... args)
+{
+#if !defined(ASIO_NO_EXCEPTIONS)
+  try
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+  {
+    f(ASIO_MOVE_CAST(Args)(args)...);
+    p.set_value();
+  }
+#if !defined(ASIO_NO_EXCEPTIONS)
+  catch (...)
+  {
+    p.set_exception(std::current_exception());
+  }
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+}
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename F>
+inline void promise_invoke_and_set(std::promise<T>& p, F& f)
+{
+#if !defined(ASIO_NO_EXCEPTIONS)
+  try
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+  {
+    p.set_value(f());
+  }
+#if !defined(ASIO_NO_EXCEPTIONS)
+  catch (...)
+  {
+    p.set_exception(std::current_exception());
+  }
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+}
+
+template <typename F, typename Args>
+inline void promise_invoke_and_set(std::promise<void>& p, F& f)
+{
+#if !defined(ASIO_NO_EXCEPTIONS)
+  try
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+  {
+    f();
+    p.set_value();
+#if !defined(ASIO_NO_EXCEPTIONS)
+  }
+  catch (...)
+  {
+    p.set_exception(std::current_exception());
+  }
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+}
+
+#if defined(ASIO_NO_EXCEPTIONS)
+
+#define ASIO_PRIVATE_PROMISE_INVOKE_DEF(n) \
+  template <typename T, typename F, ASIO_VARIADIC_TPARAMS(n)> \
+  inline void promise_invoke_and_set(std::promise<T>& p, \
+      F& f, ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    p.set_value(f(ASIO_VARIADIC_MOVE_ARGS(n))); \
+  } \
+  \
+  template <typename F, ASIO_VARIADIC_TPARAMS(n)> \
+  inline void promise_invoke_and_set(std::promise<void>& p, \
+      F& f, ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    f(ASIO_VARIADIC_MOVE_ARGS(n)); \
+    p.set_value(); \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_PROMISE_INVOKE_DEF)
+#undef ASIO_PRIVATE_PROMISE_INVOKE_DEF
+
+#else // defined(ASIO_NO_EXCEPTIONS)
+
+#define ASIO_PRIVATE_PROMISE_INVOKE_DEF(n) \
+  template <typename T, typename F, ASIO_VARIADIC_TPARAMS(n)> \
+  inline void promise_invoke_and_set(std::promise<T>& p, \
+      F& f, ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    try \
+    { \
+      p.set_value(f(ASIO_VARIADIC_MOVE_ARGS(n))); \
+    } \
+    catch (...) \
+    { \
+      p.set_exception(std::current_exception()); \
+    } \
+  } \
+  \
+  template <typename F, ASIO_VARIADIC_TPARAMS(n)> \
+  inline void promise_invoke_and_set(std::promise<void>& p, \
+      F& f, ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    try \
+    { \
+      f(ASIO_VARIADIC_MOVE_ARGS(n)); \
+      p.set_value(); \
+    } \
+    catch (...) \
+    { \
+      p.set_exception(std::current_exception()); \
+    } \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_PROMISE_INVOKE_DEF)
+#undef ASIO_PRIVATE_PROMISE_INVOKE_DEF
+
+#endif // defined(ASIO_NO_EXCEPTIONS)
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+// A function object adapter to invoke a nullary function object and capture
+// any exception thrown into a promise.
+template <typename T, typename F>
+class promise_invoker
+{
+public:
+  promise_invoker(const shared_ptr<std::promise<T> >& p,
+      ASIO_MOVE_ARG(F) f)
+    : p_(p), f_(ASIO_MOVE_CAST(F)(f))
+  {
+  }
 
-    void operator()(T t)
+  void operator()()
+  {
+#if !defined(ASIO_NO_EXCEPTIONS)
+    try
+#endif // !defined(ASIO_NO_EXCEPTIONS)
     {
-      promise_->set_value(t);
+      f_();
     }
-
-    void operator()(const asio::error_code& ec, T t)
+#if !defined(ASIO_NO_EXCEPTIONS)
+    catch (...)
     {
-      if (ec)
-        promise_->set_exception(
-            std::make_exception_ptr(
-              asio::system_error(ec)));
-      else
-        promise_->set_value(t);
+      p_->set_exception(std::current_exception());
     }
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+  }
+
+private:
+  shared_ptr<std::promise<T> > p_;
+  typename decay<F>::type f_;
+};
+
+// An executor that adapts the system_executor to capture any exeption thrown
+// by a submitted function object and save it into a promise.
+template <typename T>
+class promise_executor
+{
+public:
+  explicit promise_executor(const shared_ptr<std::promise<T> >& p)
+    : p_(p)
+  {
+  }
+
+  execution_context& context() const ASIO_NOEXCEPT
+  {
+    return system_executor().context();
+  }
+
+  void on_work_started() const ASIO_NOEXCEPT {}
+  void on_work_finished() const ASIO_NOEXCEPT {}
+
+  template <typename F, typename A>
+  void dispatch(ASIO_MOVE_ARG(F) f, const A&) const
+  {
+    promise_invoker<T, F>(p_, ASIO_MOVE_CAST(F)(f))();
+  }
+
+  template <typename F, typename A>
+  void post(ASIO_MOVE_ARG(F) f, const A& a) const
+  {
+    system_executor().post(
+        promise_invoker<T, F>(p_, ASIO_MOVE_CAST(F)(f)), a);
+  }
+
+  template <typename F, typename A>
+  void defer(ASIO_MOVE_ARG(F) f, const A& a) const
+  {
+    system_executor().defer(
+        promise_invoker<T, F>(p_, ASIO_MOVE_CAST(F)(f)), a);
+  }
+
+  friend bool operator==(const promise_executor& a,
+      const promise_executor& b) ASIO_NOEXCEPT
+  {
+    return a.p_ == b.p_;
+  }
+
+  friend bool operator!=(const promise_executor& a,
+      const promise_executor& b) ASIO_NOEXCEPT
+  {
+    return a.p_ != b.p_;
+  }
 
-  //private:
-    std::shared_ptr<std::promise<T> > promise_;
-  };
+private:
+  shared_ptr<std::promise<T> > p_;
+};
+
+// The base class for all completion handlers that create promises.
+template <typename T>
+class promise_creator
+{
+public:
+  typedef promise_executor<T> executor_type;
+
+  executor_type get_executor() const ASIO_NOEXCEPT
+  {
+    return executor_type(p_);
+  }
 
-  // Completion handler to adapt a void promise as a completion handler.
-  template <>
-  class promise_handler<void>
+  typedef std::future<T> future_type;
+
+  future_type get_future()
   {
-  public:
-    // Construct from use_future special value. Used during rebinding.
-    template <typename Allocator>
-    promise_handler(use_future_t<Allocator> uf)
-      : promise_(std::allocate_shared<std::promise<void> >(
-            uf.get_allocator(), std::allocator_arg, uf.get_allocator()))
+    return p_->get_future();
+  }
+
+protected:
+  template <typename Allocator>
+  void create_promise(const Allocator& a)
+  {
+    ASIO_REBIND_ALLOC(Allocator, char) b(a);
+    p_ = std::allocate_shared<std::promise<T>>(b, std::allocator_arg, b);
+  }
+
+  shared_ptr<std::promise<T> > p_;
+};
+
+// For completion signature void().
+class promise_handler_0
+  : public promise_creator<void>
+{
+public:
+  void operator()()
+  {
+    this->p_->set_value();
+  }
+};
+
+// For completion signature void(error_code).
+class promise_handler_ec_0
+  : public promise_creator<void>
+{
+public:
+  void operator()(const asio::error_code& ec)
+  {
+    if (ec)
     {
+      this->p_->set_exception(
+          std::make_exception_ptr(
+            asio::system_error(ec)));
     }
+    else
+    {
+      this->p_->set_value();
+    }
+  }
+};
 
-    void operator()()
+// For completion signature void(exception_ptr).
+class promise_handler_ex_0
+  : public promise_creator<void>
+{
+public:
+  void operator()(const std::exception_ptr& ex)
+  {
+    if (ex)
+    {
+      this->p_->set_exception(ex);
+    }
+    else
     {
-      promise_->set_value();
+      this->p_->set_value();
     }
+  }
+};
+
+// For completion signature void(T).
+template <typename T>
+class promise_handler_1
+  : public promise_creator<T>
+{
+public:
+  template <typename Arg>
+  void operator()(ASIO_MOVE_ARG(Arg) arg)
+  {
+    this->p_->set_value(ASIO_MOVE_CAST(Arg)(arg));
+  }
+};
 
-    void operator()(const asio::error_code& ec)
+// For completion signature void(error_code, T).
+template <typename T>
+class promise_handler_ec_1
+  : public promise_creator<T>
+{
+public:
+  template <typename Arg>
+  void operator()(const asio::error_code& ec,
+      ASIO_MOVE_ARG(Arg) arg)
+  {
+    if (ec)
     {
-      if (ec)
-        promise_->set_exception(
-            std::make_exception_ptr(
-              asio::system_error(ec)));
-      else
-        promise_->set_value();
+      this->p_->set_exception(
+          std::make_exception_ptr(
+            asio::system_error(ec)));
     }
+    else
+      this->p_->set_value(ASIO_MOVE_CAST(Arg)(arg));
+  }
+};
 
-  //private:
-    std::shared_ptr<std::promise<void> > promise_;
-  };
+// For completion signature void(exception_ptr, T).
+template <typename T>
+class promise_handler_ex_1
+  : public promise_creator<T>
+{
+public:
+  template <typename Arg>
+  void operator()(const std::exception_ptr& ex,
+      ASIO_MOVE_ARG(Arg) arg)
+  {
+    if (ex)
+      this->p_->set_exception(ex);
+    else
+      this->p_->set_value(ASIO_MOVE_CAST(Arg)(arg));
+  }
+};
 
-  // Ensure any exceptions thrown from the handler are propagated back to the
-  // caller via the future.
-  template <typename Function, typename T>
-  void asio_handler_invoke(Function f, promise_handler<T>* h)
+// For completion signature void(T1, ..., Tn);
+template <typename T>
+class promise_handler_n
+  : public promise_creator<T>
+{
+public:
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename... Args>
+  void operator()(ASIO_MOVE_ARG(Args)... args)
   {
-    std::shared_ptr<std::promise<T> > p(h->promise_);
-    try
+    this->p_->set_value(
+        std::forward_as_tuple(
+          ASIO_MOVE_CAST(Args)(args)...));
+  }
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define ASIO_PRIVATE_CALL_OP_DEF(n) \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  void operator()(ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  {\
+    this->p_->set_value( \
+        std::forward_as_tuple( \
+          ASIO_VARIADIC_MOVE_ARGS(n))); \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_CALL_OP_DEF)
+#undef ASIO_PRIVATE_CALL_OP_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+};
+
+// For completion signature void(error_code, T1, ..., Tn);
+template <typename T>
+class promise_handler_ec_n
+  : public promise_creator<T>
+{
+public:
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename... Args>
+  void operator()(const asio::error_code& ec,
+      ASIO_MOVE_ARG(Args)... args)
+  {
+    if (ec)
     {
-      f();
+      this->p_->set_exception(
+          std::make_exception_ptr(
+            asio::system_error(ec)));
     }
-    catch (...)
+    else
     {
-      p->set_exception(std::current_exception());
+      this->p_->set_value(
+          std::forward_as_tuple(
+            ASIO_MOVE_CAST(Args)(args)...));
     }
   }
 
-} // namespace detail
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
 
-#if !defined(GENERATING_DOCUMENTATION)
+#define ASIO_PRIVATE_CALL_OP_DEF(n) \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  void operator()(const asio::error_code& ec, \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  {\
+    if (ec) \
+    { \
+      this->p_->set_exception( \
+          std::make_exception_ptr( \
+            asio::system_error(ec))); \
+    } \
+    else \
+    { \
+      this->p_->set_value( \
+          std::forward_as_tuple( \
+            ASIO_VARIADIC_MOVE_ARGS(n))); \
+    } \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_CALL_OP_DEF)
+#undef ASIO_PRIVATE_CALL_OP_DEF
 
-// Handler traits specialisation for promise_handler.
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+};
+
+// For completion signature void(exception_ptr, T1, ..., Tn);
 template <typename T>
-class async_result<detail::promise_handler<T> >
+class promise_handler_ex_n
+  : public promise_creator<T>
+{
+public:
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename... Args>
+  void operator()(const std::exception_ptr& ex,
+      ASIO_MOVE_ARG(Args)... args)
+  {
+    if (ex)
+      this->p_->set_exception(ex);
+    else
+    {
+      this->p_->set_value(
+          std::forward_as_tuple(
+            ASIO_MOVE_CAST(Args)(args)...));
+    }
+  }
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define ASIO_PRIVATE_CALL_OP_DEF(n) \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  void operator()(const std::exception_ptr& ex, \
+      ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  {\
+    if (ex) \
+      this->p_->set_exception(ex); \
+    else \
+    { \
+      this->p_->set_value( \
+          std::forward_as_tuple( \
+            ASIO_VARIADIC_MOVE_ARGS(n))); \
+    } \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_CALL_OP_DEF)
+#undef ASIO_PRIVATE_CALL_OP_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+};
+
+// Helper template to choose the appropriate concrete promise handler
+// implementation based on the supplied completion signature.
+template <typename> class promise_handler_selector;
+
+template <>
+class promise_handler_selector<void()>
+  : public promise_handler_0 {};
+
+template <>
+class promise_handler_selector<void(asio::error_code)>
+  : public promise_handler_ec_0 {};
+
+template <>
+class promise_handler_selector<void(std::exception_ptr)>
+  : public promise_handler_ex_0 {};
+
+template <typename Arg>
+class promise_handler_selector<void(Arg)>
+  : public promise_handler_1<Arg> {};
+
+template <typename Arg>
+class promise_handler_selector<void(asio::error_code, Arg)>
+  : public promise_handler_ec_1<Arg> {};
+
+template <typename Arg>
+class promise_handler_selector<void(std::exception_ptr, Arg)>
+  : public promise_handler_ex_1<Arg> {};
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename... Arg>
+class promise_handler_selector<void(Arg...)>
+  : public promise_handler_n<std::tuple<Arg...> > {};
+
+template <typename... Arg>
+class promise_handler_selector<void(asio::error_code, Arg...)>
+  : public promise_handler_ec_n<std::tuple<Arg...> > {};
+
+template <typename... Arg>
+class promise_handler_selector<void(std::exception_ptr, Arg...)>
+  : public promise_handler_ex_n<std::tuple<Arg...> > {};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define ASIO_PRIVATE_PROMISE_SELECTOR_DEF(n) \
+  template <typename Arg, ASIO_VARIADIC_TPARAMS(n)> \
+  class promise_handler_selector< \
+    void(Arg, ASIO_VARIADIC_TARGS(n))> \
+      : public promise_handler_n< \
+        std::tuple<Arg, ASIO_VARIADIC_TARGS(n)> > {}; \
+  \
+  template <typename Arg, ASIO_VARIADIC_TPARAMS(n)> \
+  class promise_handler_selector< \
+    void(asio::error_code, Arg, ASIO_VARIADIC_TARGS(n))> \
+      : public promise_handler_ec_n< \
+        std::tuple<Arg, ASIO_VARIADIC_TARGS(n)> > {}; \
+  \
+  template <typename Arg, ASIO_VARIADIC_TPARAMS(n)> \
+  class promise_handler_selector< \
+    void(std::exception_ptr, Arg, ASIO_VARIADIC_TARGS(n))> \
+      : public promise_handler_ex_n< \
+        std::tuple<Arg, ASIO_VARIADIC_TARGS(n)> > {}; \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_PROMISE_SELECTOR_DEF)
+#undef ASIO_PRIVATE_PROMISE_SELECTOR_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+// Completion handlers produced from the use_future completion token, when not
+// using use_future::operator().
+template <typename Signature, typename Allocator>
+class promise_handler
+  : public promise_handler_selector<Signature>
+{
+public:
+  typedef Allocator allocator_type;
+  typedef void result_type;
+
+  promise_handler(use_future_t<Allocator> u)
+    : allocator_(u.get_allocator())
+  {
+    this->create_promise(allocator_);
+  }
+
+  allocator_type get_allocator() const ASIO_NOEXCEPT
+  {
+    return allocator_;
+  }
+
+private:
+  Allocator allocator_;
+};
+
+template <typename Function, typename Signature, typename Allocator>
+inline void asio_handler_invoke(Function& f,
+    promise_handler<Signature, Allocator>* h)
+{
+  typename promise_handler<Signature, Allocator>::executor_type
+    ex(h->get_executor());
+  ex.dispatch(ASIO_MOVE_CAST(Function)(f), std::allocator<void>());
+}
+
+template <typename Function, typename Signature, typename Allocator>
+inline void asio_handler_invoke(const Function& f,
+    promise_handler<Signature, Allocator>* h)
+{
+  typename promise_handler<Signature, Allocator>::executor_type
+    ex(h->get_executor());
+  ex.dispatch(f, std::allocator<void>());
+}
+
+// Helper base class for async_result specialisation.
+template <typename Signature, typename Allocator>
+class promise_async_result
+{
+public:
+  typedef promise_handler<Signature, Allocator> completion_handler_type;
+  typedef typename completion_handler_type::future_type return_type;
+
+  explicit promise_async_result(completion_handler_type& h)
+    : future_(h.get_future())
+  {
+  }
+
+  return_type get()
+  {
+    return ASIO_MOVE_CAST(return_type)(future_);
+  }
+
+private:
+  return_type future_;
+};
+
+// Return value from use_future::operator().
+template <typename Function, typename Allocator>
+class packaged_token
+{
+public:
+  packaged_token(Function f, const Allocator& a)
+    : function_(ASIO_MOVE_CAST(Function)(f)),
+      allocator_(a)
+  {
+  }
+
+//private:
+  Function function_;
+  Allocator allocator_;
+};
+
+// Completion handlers produced from the use_future completion token, when
+// using use_future::operator().
+template <typename Function, typename Allocator, typename Result>
+class packaged_handler
+  : public promise_creator<Result>
+{
+public:
+  typedef Allocator allocator_type;
+  typedef void result_type;
+
+  packaged_handler(packaged_token<Function, Allocator> t)
+    : function_(ASIO_MOVE_CAST(Function)(t.function_)),
+      allocator_(t.allocator_)
+  {
+    this->create_promise(allocator_);
+  }
+
+  allocator_type get_allocator() const ASIO_NOEXCEPT
+  {
+    return allocator_;
+  }
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename... Args>
+  void operator()(ASIO_MOVE_ARG(Args)... args)
+  {
+    (promise_invoke_and_set)(*this->p_,
+        function_, ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+  void operator()()
+  {
+    (promise_invoke_and_set)(*this->p_, function_);
+  }
+
+#define ASIO_PRIVATE_CALL_OP_DEF(n) \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  void operator()(ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  {\
+    (promise_invoke_and_set)(*this->p_, \
+        function_, ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_CALL_OP_DEF)
+#undef ASIO_PRIVATE_CALL_OP_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+private:
+  Function function_;
+  Allocator allocator_;
+};
+
+template <typename Function,
+    typename Function1, typename Allocator, typename Result>
+inline void asio_handler_invoke(Function& f,
+    packaged_handler<Function1, Allocator, Result>* h)
+{
+  typename packaged_handler<Function1, Allocator, Result>::executor_type
+    ex(h->get_executor());
+  ex.dispatch(ASIO_MOVE_CAST(Function)(f), std::allocator<void>());
+}
+
+template <typename Function,
+    typename Function1, typename Allocator, typename Result>
+inline void asio_handler_invoke(const Function& f,
+    packaged_handler<Function1, Allocator, Result>* h)
+{
+  typename packaged_handler<Function1, Allocator, Result>::executor_type
+    ex(h->get_executor());
+  ex.dispatch(f, std::allocator<void>());
+}
+
+// Helper base class for async_result specialisation.
+template <typename Function, typename Allocator, typename Result>
+class packaged_async_result
 {
 public:
-  // The initiating function will return a future.
-  typedef std::future<T> type;
+  typedef packaged_handler<Function, Allocator, Result> completion_handler_type;
+  typedef typename completion_handler_type::future_type return_type;
 
-  // Constructor creates a new promise for the async operation, and obtains the
-  // corresponding future.
-  explicit async_result(detail::promise_handler<T>& h)
+  explicit packaged_async_result(completion_handler_type& h)
+    : future_(h.get_future())
   {
-    value_ = h.promise_->get_future();
   }
 
-  // Obtain the future to be returned from the initiating function.
-  type get() { return std::move(value_); }
+  return_type get()
+  {
+    return ASIO_MOVE_CAST(return_type)(future_);
+  }
 
 private:
-  type value_;
+  return_type future_;
+};
+
+} // namespace detail
+
+template <typename Allocator> template <typename Function>
+inline detail::packaged_token<typename decay<Function>::type, Allocator>
+use_future_t<Allocator>::operator()(ASIO_MOVE_ARG(Function) f) const
+{
+  return detail::packaged_token<typename decay<Function>::type, Allocator>(
+      ASIO_MOVE_CAST(Function)(f), allocator_);
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Allocator, typename Result, typename... Args>
+class async_result<use_future_t<Allocator>, Result(Args...)>
+  : public detail::promise_async_result<
+      void(typename decay<Args>::type...), Allocator>
+{
+public:
+  explicit async_result(
+    typename detail::promise_async_result<void(typename decay<Args>::type...),
+      Allocator>::completion_handler_type& h)
+    : detail::promise_async_result<
+        void(typename decay<Args>::type...), Allocator>(h)
+  {
+  }
 };
 
-// Handler type specialisation for use_future.
-template <typename Allocator, typename ReturnType>
-struct handler_type<use_future_t<Allocator>, ReturnType()>
+template <typename Function, typename Allocator,
+    typename Result, typename... Args>
+class async_result<detail::packaged_token<Function, Allocator>, Result(Args...)>
+  : public detail::packaged_async_result<Function, Allocator,
+      typename result_of<Function(Args...)>::type>
 {
-  typedef detail::promise_handler<void> type;
+public:
+  explicit async_result(
+    typename detail::packaged_async_result<Function, Allocator,
+      typename result_of<Function(Args...)>::type>::completion_handler_type& h)
+    : detail::packaged_async_result<Function, Allocator,
+        typename result_of<Function(Args...)>::type>(h)
+  {
+  }
 };
 
-// Handler type specialisation for use_future.
-template <typename Allocator, typename ReturnType, typename Arg1>
-struct handler_type<use_future_t<Allocator>, ReturnType(Arg1)>
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Allocator, typename Result>
+class async_result<use_future_t<Allocator>, Result()>
+  : public detail::promise_async_result<void(), Allocator>
 {
-  typedef detail::promise_handler<Arg1> type;
+public:
+  explicit async_result(
+    typename detail::promise_async_result<
+      void(), Allocator>::completion_handler_type& h)
+    : detail::promise_async_result<void(), Allocator>(h)
+  {
+  }
 };
 
-// Handler type specialisation for use_future.
-template <typename Allocator, typename ReturnType>
-struct handler_type<use_future_t<Allocator>,
-    ReturnType(asio::error_code)>
+template <typename Function, typename Allocator, typename Result>
+class async_result<detail::packaged_token<Function, Allocator>, Result()>
+  : public detail::packaged_async_result<Function, Allocator,
+      typename result_of<Function()>::type>
 {
-  typedef detail::promise_handler<void> type;
+public:
+  explicit async_result(
+    typename detail::packaged_async_result<Function, Allocator,
+      typename result_of<Function()>::type>::completion_handler_type& h)
+    : detail::packaged_async_result<Function, Allocator,
+        typename result_of<Function()>::type>(h)
+  {
+  }
 };
 
-// Handler type specialisation for use_future.
-template <typename Allocator, typename ReturnType, typename Arg2>
-struct handler_type<use_future_t<Allocator>,
-    ReturnType(asio::error_code, Arg2)>
+#define ASIO_PRIVATE_ASYNC_RESULT_DEF(n) \
+  template <typename Allocator, \
+      typename Result, ASIO_VARIADIC_TPARAMS(n)> \
+  class async_result<use_future_t<Allocator>, \
+      Result(ASIO_VARIADIC_TARGS(n))> \
+    : public detail::promise_async_result< \
+        void(ASIO_VARIADIC_DECAY(n)), Allocator> \
+  { \
+  public: \
+    explicit async_result( \
+      typename detail::promise_async_result< \
+        void(ASIO_VARIADIC_DECAY(n)), \
+        Allocator>::completion_handler_type& h) \
+      : detail::promise_async_result< \
+          void(ASIO_VARIADIC_DECAY(n)), Allocator>(h) \
+    { \
+    } \
+  }; \
+  \
+  template <typename Function, typename Allocator, \
+      typename Result, ASIO_VARIADIC_TPARAMS(n)> \
+  class async_result<detail::packaged_token<Function, Allocator>, \
+      Result(ASIO_VARIADIC_TARGS(n))> \
+    : public detail::packaged_async_result<Function, Allocator, \
+        typename result_of<Function(ASIO_VARIADIC_TARGS(n))>::type> \
+  { \
+  public: \
+    explicit async_result( \
+      typename detail::packaged_async_result<Function, Allocator, \
+        typename result_of<Function(ASIO_VARIADIC_TARGS(n))>::type \
+        >::completion_handler_type& h) \
+      : detail::packaged_async_result<Function, Allocator, \
+          typename result_of<Function(ASIO_VARIADIC_TARGS(n))>::type>(h) \
+    { \
+    } \
+  }; \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_ASYNC_RESULT_DEF)
+#undef ASIO_PRIVATE_ASYNC_RESULT_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+#if !defined(ASIO_NO_DEPRECATED)
+
+template <typename Allocator, typename Signature>
+struct handler_type<use_future_t<Allocator>, Signature>
 {
-  typedef detail::promise_handler<Arg2> type;
+  typedef typename async_result<use_future_t<Allocator>,
+    Signature>::completion_handler_type type;
 };
 
+template <typename Signature, typename Allocator>
+class async_result<detail::promise_handler<Signature, Allocator> >
+  : public detail::promise_async_result<Signature, Allocator>
+{
+public:
+  typedef typename detail::promise_async_result<
+    Signature, Allocator>::return_type type;
+
+  explicit async_result(
+    typename detail::promise_async_result<
+      Signature, Allocator>::completion_handler_type& h)
+    : detail::promise_async_result<Signature, Allocator>(h)
+  {
+  }
+};
+
+template <typename Function, typename Allocator, typename Signature>
+struct handler_type<detail::packaged_token<Function, Allocator>, Signature>
+{
+  typedef typename async_result<detail::packaged_token<Function, Allocator>,
+    Signature>::completion_handler_type type;
+};
+
+template <typename Function, typename Allocator, typename Result>
+class async_result<detail::packaged_handler<Function, Allocator, Result> >
+  : public detail::packaged_async_result<Function, Allocator, Result>
+{
+public:
+  typedef typename detail::packaged_async_result<
+    Function, Allocator, Result>::return_type type;
+
+  explicit async_result(
+    typename detail::packaged_async_result<
+      Function, Allocator, Result>::completion_handler_type& h)
+    : detail::packaged_async_result<Function, Allocator, Result>(h)
+  {
+  }
+};
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 } // namespace asio
diff --git a/extern/include/asio/impl/write.hpp b/extern/include/asio/impl/write.hpp
index b6ac59d2..d07e8d3e 100644
--- a/extern/include/asio/impl/write.hpp
+++ b/extern/include/asio/impl/write.hpp
@@ -2,7 +2,7 @@
 // impl/write.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/buffer.hpp"
 #include "asio/completion_condition.hpp"
 #include "asio/detail/array_fwd.hpp"
@@ -32,30 +34,46 @@
 
 namespace asio {
 
-template <typename SyncWriteStream, typename ConstBufferSequence,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec)
+namespace detail
 {
-  ec = asio::error_code();
-  asio::detail::consuming_buffers<
-    const_buffer, ConstBufferSequence> tmp(buffers);
-  std::size_t total_transferred = 0;
-  tmp.prepare(detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred)));
-  while (tmp.begin() != tmp.end())
+  template <typename SyncWriteStream, typename ConstBufferSequence,
+      typename ConstBufferIterator, typename CompletionCondition>
+  std::size_t write_buffer_sequence(SyncWriteStream& s,
+      const ConstBufferSequence& buffers, const ConstBufferIterator&,
+      CompletionCondition completion_condition, asio::error_code& ec)
   {
-    std::size_t bytes_transferred = s.write_some(tmp, ec);
-    tmp.consume(bytes_transferred);
-    total_transferred += bytes_transferred;
-    tmp.prepare(detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred)));
+    ec = asio::error_code();
+    asio::detail::consuming_buffers<const_buffer,
+        ConstBufferSequence, ConstBufferIterator> tmp(buffers);
+    while (!tmp.empty())
+    {
+      if (std::size_t max_size = detail::adapt_completion_condition_result(
+            completion_condition(ec, tmp.total_consumed())))
+        tmp.consume(s.write_some(tmp.prepare(max_size), ec));
+      else
+        break;
+    }
+    return tmp.total_consumed();;
   }
-  return total_transferred;
+} // namespace detail
+
+template <typename SyncWriteStream, typename ConstBufferSequence,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
+{
+  return detail::write_buffer_sequence(s, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition, ec);
 }
 
 template <typename SyncWriteStream, typename ConstBufferSequence>
-inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   asio::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
@@ -65,7 +83,10 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
 
 template <typename SyncWriteStream, typename ConstBufferSequence>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    asio::error_code& ec)
+    asio::error_code& ec,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   return write(s, buffers, transfer_all(), ec);
 }
@@ -73,7 +94,10 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition)
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   asio::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
@@ -81,35 +105,92 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
   return bytes_transferred;
 }
 
-#if !defined(ASIO_NO_IOSTREAM)
-
-template <typename SyncWriteStream, typename Allocator,
+template <typename SyncWriteStream, typename DynamicBuffer,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
 {
+  typename decay<DynamicBuffer>::type b(
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
   b.consume(bytes_transferred);
   return bytes_transferred;
 }
 
-template <typename SyncWriteStream, typename Allocator>
+template <typename SyncWriteStream, typename DynamicBuffer>
 inline std::size_t write(SyncWriteStream& s,
-    asio::basic_streambuf<Allocator>& b)
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
 {
   asio::error_code ec;
-  std::size_t bytes_transferred = write(s, b, transfer_all(), ec);
+  std::size_t bytes_transferred = write(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), ec);
   asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
+template <typename SyncWriteStream, typename DynamicBuffer>
+inline std::size_t write(SyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
+{
+  return write(s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), ec);
+}
+
+template <typename SyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
+{
+  asio::error_code ec;
+  std::size_t bytes_transferred = write(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      completion_condition, ec);
+  asio::detail::throw_error(ec, "write");
+  return bytes_transferred;
+}
+
+#if !defined(ASIO_NO_EXTENSIONS)
+#if !defined(ASIO_NO_IOSTREAM)
+
+template <typename SyncWriteStream, typename Allocator,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, asio::error_code& ec)
+{
+  return write(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec);
+}
+
+template <typename SyncWriteStream, typename Allocator>
+inline std::size_t write(SyncWriteStream& s,
+    asio::basic_streambuf<Allocator>& b)
+{
+  return write(s, basic_streambuf_ref<Allocator>(b));
+}
+
 template <typename SyncWriteStream, typename Allocator>
 inline std::size_t write(SyncWriteStream& s,
     asio::basic_streambuf<Allocator>& b,
     asio::error_code& ec)
 {
-  return write(s, b, transfer_all(), ec);
+  return write(s, basic_streambuf_ref<Allocator>(b), ec);
 }
 
 template <typename SyncWriteStream, typename Allocator,
@@ -118,18 +199,17 @@ inline std::size_t write(SyncWriteStream& s,
     asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition)
 {
-  asio::error_code ec;
-  std::size_t bytes_transferred = write(s, b, completion_condition, ec);
-  asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
+  return write(s, basic_streambuf_ref<Allocator>(b), completion_condition);
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 namespace detail
 {
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   class write_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
@@ -141,7 +221,6 @@ namespace detail
         stream_(stream),
         buffers_(buffers),
         start_(0),
-        total_transferred_(0),
         handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
@@ -152,7 +231,6 @@ namespace detail
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
@@ -162,7 +240,6 @@ namespace detail
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
     }
@@ -171,362 +248,39 @@ namespace detail
     void operator()(const asio::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
+      std::size_t max_size;
       switch (start_ = start)
       {
         case 1:
-        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-        for (;;)
+        max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        do
         {
-          stream_.async_write_some(buffers_,
+          stream_.async_write_some(buffers_.prepare(max_size),
               ASIO_MOVE_CAST(write_op)(*this));
           return; default:
-          total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
-          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-          if ((!ec && bytes_transferred == 0)
-              || buffers_.begin() == buffers_.end())
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    asio::detail::consuming_buffers<
-      const_buffer, ConstBufferSequence> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, asio::mutable_buffers_1,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream,
-        const asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition,
-        WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          stream_.async_write_some(
-              asio::buffer(buffer_ + total_transferred_, n),
-              ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    asio::mutable_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, asio::const_buffers_1,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream,
-        const asio::const_buffers_1& buffers,
-        CompletionCondition completion_condition,
-        WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          stream_.async_write_some(
-              asio::buffer(buffer_ + total_transferred_, n),
-              ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    asio::const_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, boost::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          boost::array<asio::const_buffer, 2> >::type bufs = {{
-        asio::const_buffer(buffers_[0]),
-        asio::const_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          stream_.async_write_some(bufs, ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
+          if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
-        }
+          max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        } while (max_size > 0);
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        handler_(ec, buffers_.total_consumed());
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
-    boost::array<Elem, 2> buffers_;
+    asio::detail::consuming_buffers<const_buffer,
+        ConstBufferSequence, ConstBufferIterator> buffers_;
     int start_;
-    std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
-#if defined(ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncWriteStream, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, std::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          std::array<asio::const_buffer, 2> >::type bufs = {{
-        asio::const_buffer(buffers_[0]),
-        asio::const_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          stream_.async_write_some(bufs, ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    std::array<Elem, 2> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#endif // defined(ASIO_HAS_STD_ARRAY)
-
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
@@ -534,9 +288,10 @@ namespace detail
   }
 
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
@@ -544,9 +299,10 @@ namespace detail
   }
 
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   inline bool asio_handler_is_continuation(
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
@@ -555,10 +311,10 @@ namespace detail
   }
 
   template <typename Function, typename AsyncWriteStream,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
+      typename ConstBufferSequence, typename ConstBufferIterator,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_invoke(Function& function,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
@@ -566,38 +322,94 @@ namespace detail
   }
 
   template <typename Function, typename AsyncWriteStream,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
+      typename ConstBufferSequence, typename ConstBufferIterator,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
+  inline void start_write_buffer_sequence_op(AsyncWriteStream& stream,
+      const ConstBufferSequence& buffers, const ConstBufferIterator&,
+      CompletionCondition completion_condition, WriteHandler& handler)
+  {
+    detail::write_op<AsyncWriteStream, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>(
+        stream, buffers, completion_condition, handler)(
+          asio::error_code(), 0, 1);
+  }
+
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncWriteStream, typename ConstBufferSequence,
+    typename ConstBufferIterator, typename CompletionCondition,
+    typename WriteHandler, typename Allocator>
+struct associated_allocator<
+    detail::write_op<AsyncWriteStream, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+
+  static type get(
+      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
+        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncWriteStream, typename ConstBufferSequence,
+    typename ConstBufferIterator, typename CompletionCondition,
+    typename WriteHandler, typename Executor>
+struct associated_executor<
+    detail::write_op<AsyncWriteStream, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>,
+    Executor>
+{
+  typedef typename associated_executor<WriteHandler, Executor>::type type;
+
+  static type get(
+      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
+        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename AsyncWriteStream, typename ConstBufferSequence,
   typename CompletionCondition, typename WriteHandler>
 inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (asio::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(WriteHandler) handler)
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::write_op<AsyncWriteStream, ConstBufferSequence,
-    CompletionCondition, ASIO_HANDLER_TYPE(
-      WriteHandler, void (asio::error_code, std::size_t))>(
-        s, buffers, completion_condition, init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_write_buffer_sequence_op(s, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition,
+      init.completion_handler);
 
   return init.result.get();
 }
@@ -607,132 +419,227 @@ template <typename AsyncWriteStream, typename ConstBufferSequence,
 inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (asio::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    ASIO_MOVE_ARG(WriteHandler) handler)
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::write_op<AsyncWriteStream, ConstBufferSequence,
-    detail::transfer_all_t, ASIO_HANDLER_TYPE(
-      WriteHandler, void (asio::error_code, std::size_t))>(
-        s, buffers, transfer_all(), init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_write_buffer_sequence_op(s, buffers,
+      asio::buffer_sequence_begin(buffers), transfer_all(),
+      init.completion_handler);
 
   return init.result.get();
 }
 
-#if !defined(ASIO_NO_IOSTREAM)
-
 namespace detail
 {
-  template <typename Allocator, typename WriteHandler>
-  class write_streambuf_handler
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
+  class write_dynbuf_op
   {
   public:
-    write_streambuf_handler(asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler& handler)
-      : streambuf_(streambuf),
+    template <typename BufferSequence>
+    write_dynbuf_op(AsyncWriteStream& stream,
+        ASIO_MOVE_ARG(BufferSequence) buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : stream_(stream),
+        buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),
+        completion_condition_(
+          ASIO_MOVE_CAST(CompletionCondition)(completion_condition)),
         handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(ASIO_HAS_MOVE)
-    write_streambuf_handler(const write_streambuf_handler& other)
-      : streambuf_(other.streambuf_),
+    write_dynbuf_op(const write_dynbuf_op& other)
+      : stream_(other.stream_),
+        buffers_(other.buffers_),
+        completion_condition_(other.completion_condition_),
         handler_(other.handler_)
     {
     }
 
-    write_streambuf_handler(write_streambuf_handler&& other)
-      : streambuf_(other.streambuf_),
+    write_dynbuf_op(write_dynbuf_op&& other)
+      : stream_(other.stream_),
+        buffers_(ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
+        completion_condition_(
+          ASIO_MOVE_CAST(CompletionCondition)(
+            other.completion_condition_)),
         handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
     }
 #endif // defined(ASIO_HAS_MOVE)
 
     void operator()(const asio::error_code& ec,
-        const std::size_t bytes_transferred)
+        std::size_t bytes_transferred, int start = 0)
     {
-      streambuf_.consume(bytes_transferred);
-      handler_(ec, bytes_transferred);
+      switch (start)
+      {
+        case 1:
+        async_write(stream_, buffers_.data(), completion_condition_,
+            ASIO_MOVE_CAST(write_dynbuf_op)(*this));
+        return; default:
+        buffers_.consume(bytes_transferred);
+        handler_(ec, static_cast<const std::size_t&>(bytes_transferred));
+      }
     }
 
   //private:
-    asio::basic_streambuf<Allocator>& streambuf_;
+    AsyncWriteStream& stream_;
+    DynamicBuffer buffers_;
+    CompletionCondition completion_condition_;
     WriteHandler handler_;
   };
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
   inline bool asio_handler_is_continuation(
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     return asio_handler_cont_helpers::is_continuation(
         this_handler->handler_);
   }
 
-  template <typename Function, typename Allocator, typename WriteHandler>
+  template <typename Function, typename AsyncWriteStream,
+      typename DynamicBuffer, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_invoke(Function& function,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename Allocator, typename WriteHandler>
+  template <typename Function, typename AsyncWriteStream,
+      typename DynamicBuffer, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncWriteStream, typename Allocator,
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition, typename WriteHandler, typename Allocator>
+struct associated_allocator<
+    detail::write_dynbuf_op<AsyncWriteStream,
+      DynamicBuffer, CompletionCondition, WriteHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+
+  static type get(
+      const detail::write_dynbuf_op<AsyncWriteStream,
+        DynamicBuffer, CompletionCondition, WriteHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition, typename WriteHandler, typename Executor>
+struct associated_executor<
+    detail::write_dynbuf_op<AsyncWriteStream,
+      DynamicBuffer, CompletionCondition, WriteHandler>,
+    Executor>
+{
+  typedef typename associated_executor<WriteHandler, Executor>::type type;
+
+  static type get(
+      const detail::write_dynbuf_op<AsyncWriteStream,
+        DynamicBuffer, CompletionCondition, WriteHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncWriteStream,
+    typename DynamicBuffer, typename WriteHandler>
+inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (asio::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
+{
+  return async_write(s,
+      ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), ASIO_MOVE_CAST(WriteHandler)(handler));
+}
+
+template <typename AsyncWriteStream, typename DynamicBuffer,
     typename CompletionCondition, typename WriteHandler>
 inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (asio::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
-    asio::basic_streambuf<Allocator>& b,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(WriteHandler) handler)
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  async_write(s, b.data(), completion_condition,
-    detail::write_streambuf_handler<Allocator, ASIO_HANDLER_TYPE(
-      WriteHandler, void (asio::error_code, std::size_t))>(
-        b, init.handler));
+  detail::write_dynbuf_op<AsyncWriteStream,
+    typename decay<DynamicBuffer>::type,
+      CompletionCondition, ASIO_HANDLER_TYPE(
+        WriteHandler, void (asio::error_code, std::size_t))>(
+          s, ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            completion_condition, init.completion_handler)(
+              asio::error_code(), 0, 1);
 
   return init.result.get();
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
+#if !defined(ASIO_NO_IOSTREAM)
+
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
 inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (asio::error_code, std::size_t))
@@ -740,23 +647,25 @@ async_write(AsyncWriteStream& s,
     asio::basic_streambuf<Allocator>& b,
     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.
-  ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
+  return async_write(s, basic_streambuf_ref<Allocator>(b),
       ASIO_MOVE_CAST(WriteHandler)(handler));
+}
 
-  async_write(s, b.data(), transfer_all(),
-    detail::write_streambuf_handler<Allocator, ASIO_HANDLER_TYPE(
-      WriteHandler, void (asio::error_code, std::size_t))>(
-        b, init.handler));
-
-  return init.result.get();
+template <typename AsyncWriteStream, typename Allocator,
+    typename CompletionCondition, typename WriteHandler>
+inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (asio::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  return async_write(s, basic_streambuf_ref<Allocator>(b),
+      completion_condition, ASIO_MOVE_CAST(WriteHandler)(handler));
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 } // namespace asio
 
diff --git a/extern/include/asio/impl/write_at.hpp b/extern/include/asio/impl/write_at.hpp
index 7a27958c..cc6f336f 100644
--- a/extern/include/asio/impl/write_at.hpp
+++ b/extern/include/asio/impl/write_at.hpp
@@ -2,7 +2,7 @@
 // impl/write_at.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/associated_allocator.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/buffer.hpp"
 #include "asio/completion_condition.hpp"
 #include "asio/detail/array_fwd.hpp"
@@ -32,28 +34,41 @@
 
 namespace asio {
 
+namespace detail
+{
+  template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename ConstBufferIterator, typename CompletionCondition>
+  std::size_t write_at_buffer_sequence(SyncRandomAccessWriteDevice& d,
+      uint64_t offset, const ConstBufferSequence& buffers,
+      const ConstBufferIterator&, CompletionCondition completion_condition,
+      asio::error_code& ec)
+  {
+    ec = asio::error_code();
+    asio::detail::consuming_buffers<const_buffer,
+        ConstBufferSequence, ConstBufferIterator> tmp(buffers);
+    while (!tmp.empty())
+    {
+      if (std::size_t max_size = detail::adapt_completion_condition_result(
+            completion_condition(ec, tmp.total_consumed())))
+      {
+        tmp.consume(d.write_some_at(offset + tmp.total_consumed(),
+              tmp.prepare(max_size), ec));
+      }
+      else
+        break;
+    }
+    return tmp.total_consumed();;
+  }
+} // namespace detail
+
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition, asio::error_code& ec)
 {
-  ec = asio::error_code();
-  asio::detail::consuming_buffers<
-    const_buffer, ConstBufferSequence> tmp(buffers);
-  std::size_t total_transferred = 0;
-  tmp.prepare(detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred)));
-  while (tmp.begin() != tmp.end())
-  {
-    std::size_t bytes_transferred = d.write_some_at(
-        offset + total_transferred, tmp, ec);
-    tmp.consume(bytes_transferred);
-    total_transferred += bytes_transferred;
-    tmp.prepare(detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred)));
-  }
-  return total_transferred;
+  return detail::write_at_buffer_sequence(d, offset, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition, ec);
 }
 
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
@@ -88,6 +103,7 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
   return bytes_transferred;
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
@@ -134,10 +150,12 @@ inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 namespace detail
 {
-  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+  template <typename AsyncRandomAccessWriteDevice,
+      typename ConstBufferSequence, typename ConstBufferIterator,
       typename CompletionCondition, typename WriteHandler>
   class write_at_op
     : detail::base_from_completion_cond<CompletionCondition>
@@ -152,7 +170,6 @@ namespace detail
         offset_(offset),
         buffers_(buffers),
         start_(0),
-        total_transferred_(0),
         handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
@@ -164,7 +181,6 @@ namespace detail
         offset_(other.offset_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
@@ -175,7 +191,6 @@ namespace detail
         offset_(other.offset_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
     }
@@ -184,405 +199,64 @@ namespace detail
     void operator()(const asio::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
+      std::size_t max_size;
       switch (start_ = start)
       {
         case 1:
-        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-        for (;;)
+        max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        do
         {
           device_.async_write_some_at(
-              offset_ + total_transferred_, buffers_,
+              offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
               ASIO_MOVE_CAST(write_at_op)(*this));
           return; default:
-          total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
-          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-          if ((!ec && bytes_transferred == 0)
-              || buffers_.begin() == buffers_.end())
+          if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
-        }
+          max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        } while (max_size > 0);
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        handler_(ec, buffers_.total_consumed());
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
     uint64_t offset_;
-    asio::detail::consuming_buffers<
-      const_buffer, ConstBufferSequence> buffers_;
+    asio::detail::consuming_buffers<const_buffer,
+        ConstBufferSequence, ConstBufferIterator> buffers_;
     int start_;
-    std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncRandomAccessWriteDevice,
-      typename CompletionCondition, typename WriteHandler>
-  class write_at_op<AsyncRandomAccessWriteDevice,
-      asio::mutable_buffers_1, CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_at_op(AsyncRandomAccessWriteDevice& device,
-        uint64_t offset, const asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition,
-        WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(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_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          device_.async_write_some_at(offset_ + total_transferred_,
-              asio::buffer(buffer_ + total_transferred_, n),
-              ASIO_MOVE_CAST(write_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessWriteDevice& device_;
-    uint64_t offset_;
-    asio::mutable_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncRandomAccessWriteDevice,
-      typename CompletionCondition, typename WriteHandler>
-  class write_at_op<AsyncRandomAccessWriteDevice, asio::const_buffers_1,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_at_op(AsyncRandomAccessWriteDevice& device,
-        uint64_t offset, const asio::const_buffers_1& buffers,
-        CompletionCondition completion_condition,
-        WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(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_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          device_.async_write_some_at(offset_ + total_transferred_,
-              asio::buffer(buffer_ + total_transferred_, n),
-              ASIO_MOVE_CAST(write_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessWriteDevice& device_;
-    uint64_t offset_;
-    asio::const_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncRandomAccessWriteDevice, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_at_op<AsyncRandomAccessWriteDevice, boost::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_at_op(AsyncRandomAccessWriteDevice& device,
-        uint64_t offset, const boost::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(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_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          boost::array<asio::const_buffer, 2> >::type bufs = {{
-        asio::const_buffer(buffers_[0]),
-        asio::const_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          device_.async_write_some_at(offset_ + total_transferred_,
-              bufs, ASIO_MOVE_CAST(write_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessWriteDevice& device_;
-    uint64_t offset_;
-    boost::array<Elem, 2> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#if defined(ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncRandomAccessWriteDevice, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_at_op<AsyncRandomAccessWriteDevice, std::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_at_op(AsyncRandomAccessWriteDevice& device,
-        uint64_t offset, const std::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(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_),
-        start_(other.start_),
-        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_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(ASIO_HAS_MOVE)
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename asio::detail::dependent_type<Elem,
-          std::array<asio::const_buffer, 2> >::type bufs = {{
-        asio::const_buffer(buffers_[0]),
-        asio::const_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - asio::buffer_size(bufs[0]));
-          device_.async_write_some_at(offset_ + total_transferred_,
-              bufs, ASIO_MOVE_CAST(write_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessWriteDevice& device_;
-    uint64_t offset_;
-    std::array<Elem, 2> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#endif // defined(ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename ConstBufferSequence, typename ConstBufferIterator,
       typename CompletionCondition, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-        CompletionCondition, WriteHandler>* this_handler)
+        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+  template <typename AsyncRandomAccessWriteDevice,
+      typename ConstBufferSequence, typename ConstBufferIterator,
       typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-        CompletionCondition, WriteHandler>* this_handler)
+        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+  template <typename AsyncRandomAccessWriteDevice,
+      typename ConstBufferSequence, typename ConstBufferIterator,
       typename CompletionCondition, typename WriteHandler>
   inline bool asio_handler_is_continuation(
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-        CompletionCondition, WriteHandler>* this_handler)
+        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : asio_handler_cont_helpers::is_continuation(
@@ -590,41 +264,86 @@ namespace detail
   }
 
   template <typename Function, typename AsyncRandomAccessWriteDevice,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
+      typename ConstBufferSequence, typename ConstBufferIterator,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_invoke(Function& function,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-        CompletionCondition, WriteHandler>* this_handler)
+        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
   template <typename Function, typename AsyncRandomAccessWriteDevice,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
+      typename ConstBufferSequence, typename ConstBufferIterator,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-        CompletionCondition, WriteHandler>* this_handler)
+        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+  template <typename AsyncRandomAccessWriteDevice,
+      typename ConstBufferSequence, typename ConstBufferIterator,
       typename CompletionCondition, typename WriteHandler>
-  inline write_at_op<AsyncRandomAccessWriteDevice,
-      ConstBufferSequence, CompletionCondition, WriteHandler>
-  make_write_at_op(AsyncRandomAccessWriteDevice& d,
+  inline void start_write_at_buffer_sequence_op(AsyncRandomAccessWriteDevice& d,
       uint64_t offset, const ConstBufferSequence& buffers,
-      CompletionCondition completion_condition, WriteHandler handler)
+      const ConstBufferIterator&, CompletionCondition completion_condition,
+      WriteHandler& handler)
   {
-    return write_at_op<AsyncRandomAccessWriteDevice,
-      ConstBufferSequence, CompletionCondition, WriteHandler>(
-        d, offset, buffers, completion_condition, handler);
+    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>(
+        d, offset, buffers, completion_condition, handler)(
+          asio::error_code(), 0, 1);
   }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncRandomAccessWriteDevice,
+    typename ConstBufferSequence, typename ConstBufferIterator,
+    typename CompletionCondition, typename WriteHandler, typename Allocator>
+struct associated_allocator<
+    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+
+  static type get(
+      const detail::write_at_op<AsyncRandomAccessWriteDevice,
+        ConstBufferSequence, ConstBufferIterator,
+        CompletionCondition, WriteHandler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncRandomAccessWriteDevice,
+    typename ConstBufferSequence, typename ConstBufferIterator,
+    typename CompletionCondition, typename WriteHandler, typename Executor>
+struct associated_executor<
+    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>,
+    Executor>
+{
+  typedef typename associated_executor<WriteHandler, Executor>::type type;
+
+  static type get(
+      const detail::write_at_op<AsyncRandomAccessWriteDevice,
+        ConstBufferSequence, ConstBufferIterator,
+        CompletionCondition, WriteHandler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
 inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
@@ -638,15 +357,12 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-    CompletionCondition, ASIO_HANDLER_TYPE(
-      WriteHandler, void (asio::error_code, std::size_t))>(
-        d, offset, buffers, completion_condition, init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_write_at_buffer_sequence_op(d, offset, buffers,
+      asio::buffer_sequence_begin(buffers), completion_condition,
+      init.completion_handler);
 
   return init.result.get();
 }
@@ -663,19 +379,17 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
-  detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-    detail::transfer_all_t, ASIO_HANDLER_TYPE(
-      WriteHandler, void (asio::error_code, std::size_t))>(
-        d, offset, buffers, transfer_all(), init.handler)(
-          asio::error_code(), 0, 1);
+  detail::start_write_at_buffer_sequence_op(d, offset, buffers,
+      asio::buffer_sequence_begin(buffers), transfer_all(),
+      init.completion_handler);
 
   return init.result.get();
 }
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 namespace detail
@@ -767,6 +481,40 @@ namespace detail
   }
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Allocator, typename WriteHandler, typename Allocator1>
+struct associated_allocator<
+    detail::write_at_streambuf_op<Allocator, WriteHandler>,
+    Allocator1>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator1>::type type;
+
+  static type get(
+      const detail::write_at_streambuf_op<Allocator, WriteHandler>& h,
+      const Allocator1& a = Allocator1()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator1>::get(h.handler_, a);
+  }
+};
+
+template <typename Executor, typename WriteHandler, typename Executor1>
+struct associated_executor<
+    detail::write_at_streambuf_op<Executor, WriteHandler>,
+    Executor1>
+{
+  typedef typename associated_executor<WriteHandler, Executor1>::type type;
+
+  static type get(
+      const detail::write_at_streambuf_op<Executor, WriteHandler>& h,
+      const Executor1& ex = Executor1()) ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor1>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
 inline ASIO_INITFN_RESULT_TYPE(WriteHandler,
@@ -780,14 +528,13 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   async_write_at(d, offset, b.data(), completion_condition,
     detail::write_at_streambuf_op<Allocator, ASIO_HANDLER_TYPE(
       WriteHandler, void (asio::error_code, std::size_t))>(
-        b, init.handler));
+        b, init.completion_handler));
 
   return init.result.get();
 }
@@ -804,19 +551,19 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
   // not meet the documented type requirements for a WriteHandler.
   ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (asio::error_code, std::size_t)> init(
-      ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (asio::error_code, std::size_t)> init(handler);
 
   async_write_at(d, offset, b.data(), transfer_all(),
     detail::write_at_streambuf_op<Allocator, ASIO_HANDLER_TYPE(
       WriteHandler, void (asio::error_code, std::size_t))>(
-        b, init.handler));
+        b, init.completion_handler));
 
   return init.result.get();
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 } // namespace asio
 
diff --git a/extern/include/asio/io_context.hpp b/extern/include/asio/io_context.hpp
new file mode 100644
index 00000000..4d93be44
--- /dev/null
+++ b/extern/include/asio/io_context.hpp
@@ -0,0 +1,876 @@
+//
+// io_context.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IO_CONTEXT_HPP
+#define ASIO_IO_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <cstddef>
+#include <stdexcept>
+#include <typeinfo>
+#include "asio/async_result.hpp"
+#include "asio/detail/noncopyable.hpp"
+#include "asio/detail/wrapped_handler.hpp"
+#include "asio/error_code.hpp"
+#include "asio/execution_context.hpp"
+
+#if defined(ASIO_HAS_CHRONO)
+# include "asio/detail/chrono.hpp"
+#endif // defined(ASIO_HAS_CHRONO)
+
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+# include "asio/detail/winsock_init.hpp"
+#elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
+  || defined(__osf__)
+# include "asio/detail/signal_init.hpp"
+#endif
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+namespace detail {
+#if defined(ASIO_HAS_IOCP)
+  typedef class win_iocp_io_context io_context_impl;
+  class win_iocp_overlapped_ptr;
+#else
+  typedef class scheduler io_context_impl;
+#endif
+} // namespace detail
+
+/// Provides core I/O functionality.
+/**
+ * The io_context class provides the core I/O functionality for users of the
+ * asynchronous I/O objects, including:
+ *
+ * @li asio::ip::tcp::socket
+ * @li asio::ip::tcp::acceptor
+ * @li asio::ip::udp::socket
+ * @li asio::deadline_timer.
+ *
+ * The io_context class also includes facilities intended for developers of
+ * custom asynchronous services.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe, with the specific exceptions of the restart()
+ * and notify_fork() functions. Calling restart() while there are unfinished
+ * run(), run_one(), run_for(), run_until(), poll() or poll_one() calls results
+ * in undefined behaviour. The notify_fork() function should not be called
+ * while any io_context function, or any function on an I/O object that is
+ * associated with the io_context, is being called in another thread.
+ *
+ * @par Concepts:
+ * Dispatcher.
+ *
+ * @par Synchronous and asynchronous operations
+ *
+ * Synchronous operations on I/O objects implicitly run the io_context object
+ * for an individual operation. The io_context functions run(), run_one(),
+ * run_for(), run_until(), poll() or poll_one() must be called for the
+ * io_context to perform asynchronous operations on behalf of a C++ program.
+ * Notification that an asynchronous operation has completed is delivered by
+ * invocation of the associated handler. Handlers are invoked only by a thread
+ * that is currently calling any overload of run(), run_one(), run_for(),
+ * run_until(), poll() or poll_one() for the io_context.
+ *
+ * @par Effect of exceptions thrown from handlers
+ *
+ * If an exception is thrown from a handler, the exception is allowed to
+ * propagate through the throwing thread's invocation of run(), run_one(),
+ * run_for(), run_until(), poll() or poll_one(). No other threads that are
+ * calling any of these functions are affected. It is then the responsibility
+ * of the application to catch the exception.
+ *
+ * After the exception has been caught, the run(), run_one(), run_for(),
+ * run_until(), poll() or poll_one() call may be restarted @em without the need
+ * for an intervening call to restart(). This allows the thread to rejoin the
+ * io_context object's thread pool without impacting any other threads in the
+ * pool.
+ *
+ * For example:
+ *
+ * @code
+ * asio::io_context io_context;
+ * ...
+ * for (;;)
+ * {
+ *   try
+ *   {
+ *     io_context.run();
+ *     break; // run() exited normally
+ *   }
+ *   catch (my_exception& e)
+ *   {
+ *     // Deal with exception as appropriate.
+ *   }
+ * }
+ * @endcode
+ *
+ * @par Submitting arbitrary tasks to the io_context
+ *
+ * To submit functions to the io_context, use the @ref asio::dispatch,
+ * @ref asio::post or @ref asio::defer free functions.
+ *
+ * For example:
+ *
+ * @code void my_task()
+ * {
+ *   ...
+ * }
+ *
+ * ...
+ *
+ * asio::io_context io_context;
+ *
+ * // Submit a function to the io_context.
+ * asio::post(io_context, my_task);
+ *
+ * // Submit a lambda object to the io_context.
+ * asio::post(io_context,
+ *     []()
+ *     {
+ *       ...
+ *     });
+ *
+ * // Run the io_context until it runs out of work.
+ * io_context.run(); @endcode
+ *
+ * @par Stopping the io_context from running out of work
+ *
+ * Some applications may need to prevent an io_context object's run() call from
+ * returning when there is no more work to do. For example, the io_context may
+ * be being run in a background thread that is launched prior to the
+ * application's asynchronous operations. The run() call may be kept running by
+ * creating an object of type
+ * asio::executor_work_guard<io_context::executor_type>:
+ *
+ * @code asio::io_context io_context;
+ * asio::executor_work_guard<asio::io_context::executor_type>
+ *   = asio::make_work_guard(io_context);
+ * ... @endcode
+ *
+ * To effect a shutdown, the application will then need to call the io_context
+ * object's stop() member function. This will cause the io_context run() call
+ * to return as soon as possible, abandoning unfinished operations and without
+ * permitting ready handlers to be dispatched.
+ *
+ * Alternatively, if the application requires that all operations and handlers
+ * be allowed to finish normally, the work object may be explicitly reset.
+ *
+ * @code asio::io_context io_context;
+ * asio::executor_work_guard<asio::io_context::executor_type>
+ *   = asio::make_work_guard(io_context);
+ * ...
+ * work.reset(); // Allow run() to exit. @endcode
+ */
+class io_context
+  : public execution_context
+{
+private:
+  typedef detail::io_context_impl impl_type;
+#if defined(ASIO_HAS_IOCP)
+  friend class detail::win_iocp_overlapped_ptr;
+#endif
+
+public:
+  class executor_type;
+  friend class executor_type;
+
+#if !defined(ASIO_NO_DEPRECATED)
+  class work;
+  friend class work;
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  class service;
+
+#if !defined(ASIO_NO_EXTENSIONS)
+  class strand;
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
+  /// The type used to count the number of handlers executed by the context.
+  typedef std::size_t count_type;
+
+  /// Constructor.
+  ASIO_DECL io_context();
+
+  /// Constructor.
+  /**
+   * Construct with a hint about the required level of concurrency.
+   *
+   * @param concurrency_hint A suggestion to the implementation on how many
+   * threads it should allow to run simultaneously.
+   */
+  ASIO_DECL explicit io_context(int concurrency_hint);
+
+  /// Destructor.
+  /**
+   * On destruction, the io_context performs the following sequence of
+   * operations:
+   *
+   * @li For each service object @c svc in the io_context set, in reverse order
+   * of the beginning of service object lifetime, performs
+   * @c svc->shutdown().
+   *
+   * @li Uninvoked handler objects that were scheduled for deferred invocation
+   * on the io_context, or any associated strand, are destroyed.
+   *
+   * @li For each service object @c svc in the io_context set, in reverse order
+   * of the beginning of service object lifetime, performs
+   * <tt>delete static_cast<io_context::service*>(svc)</tt>.
+   *
+   * @note The destruction sequence described above permits programs to
+   * simplify their resource management by using @c shared_ptr<>. Where an
+   * object's lifetime is tied to the lifetime of a connection (or some other
+   * sequence of asynchronous operations), a @c shared_ptr to the object would
+   * be bound into the handlers for all asynchronous operations associated with
+   * it. This works as follows:
+   *
+   * @li When a single connection ends, all associated asynchronous operations
+   * complete. The corresponding handler objects are destroyed, and all
+   * @c shared_ptr references to the objects are destroyed.
+   *
+   * @li To shut down the whole program, the io_context function stop() is
+   * called to terminate any run() calls as soon as possible. The io_context
+   * destructor defined above destroys all handlers, causing all @c shared_ptr
+   * references to all connection objects to be destroyed.
+   */
+  ASIO_DECL ~io_context();
+
+  /// Obtains the executor associated with the io_context.
+  executor_type get_executor() ASIO_NOEXCEPT;
+
+  /// Run the io_context object's event processing loop.
+  /**
+   * The run() function blocks until all work has finished and there are no
+   * more handlers to be dispatched, or until the io_context has been stopped.
+   *
+   * Multiple threads may call the run() function to set up a pool of threads
+   * from which the io_context may execute handlers. All threads that are
+   * waiting in the pool are equivalent and the io_context may choose any one
+   * of them to invoke a handler.
+   *
+   * A normal exit from the run() function implies that the io_context 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 restart().
+   *
+   * @return The number of handlers that were executed.
+   *
+   * @note Calling the run() function from a thread that is currently calling
+   * one of run(), run_one(), run_for(), run_until(), poll() or poll_one() on
+   * the same io_context object may introduce the potential for deadlock. It is
+   * the caller's reponsibility to avoid this.
+   *
+   * The poll() function may also be used to dispatch ready handlers, but
+   * without blocking.
+   */
+  ASIO_DECL count_type run();
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
+  /// event processing loop.
+  /**
+   * The run() function blocks until all work has finished and there are no
+   * more handlers to be dispatched, or until the io_context has been stopped.
+   *
+   * Multiple threads may call the run() function to set up a pool of threads
+   * from which the io_context may execute handlers. All threads that are
+   * waiting in the pool are equivalent and the io_context may choose any one
+   * of them to invoke a handler.
+   *
+   * A normal exit from the run() function implies that the io_context 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 restart().
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @return The number of handlers that were executed.
+   *
+   * @note Calling the run() function from a thread that is currently calling
+   * one of run(), run_one(), run_for(), run_until(), poll() or poll_one() on
+   * the same io_context object may introduce the potential for deadlock. It is
+   * the caller's reponsibility to avoid this.
+   *
+   * The poll() function may also be used to dispatch ready handlers, but
+   * without blocking.
+   */
+  ASIO_DECL count_type run(asio::error_code& ec);
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+#if defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
+  /// Run the io_context object's event processing loop for a specified
+  /// duration.
+  /**
+   * The run_for() function blocks until all work has finished and there are no
+   * more handlers to be dispatched, until the io_context has been stopped, or
+   * until the specified duration has elapsed.
+   *
+   * @param rel_time The duration for which the call may block.
+   *
+   * @return The number of handlers that were executed.
+   */
+  template <typename Rep, typename Period>
+  std::size_t run_for(const chrono::duration<Rep, Period>& rel_time);
+
+  /// Run the io_context object's event processing loop until a specified time.
+  /**
+   * The run_until() function blocks until all work has finished and there are
+   * no more handlers to be dispatched, until the io_context has been stopped,
+   * or until the specified time has been reached.
+   *
+   * @param abs_time The time point until which the call may block.
+   *
+   * @return The number of handlers that were executed.
+   */
+  template <typename Clock, typename Duration>
+  std::size_t run_until(const chrono::time_point<Clock, Duration>& abs_time);
+#endif // defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
+
+  /// Run the io_context object's event processing loop to execute at most one
+  /// handler.
+  /**
+   * The run_one() function blocks until one handler has been dispatched, or
+   * until the io_context has been stopped.
+   *
+   * @return The number of handlers that were executed. A zero return value
+   * implies that the io_context 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
+   * restart().
+   *
+   * @note Calling the run_one() function from a thread that is currently
+   * calling one of run(), run_one(), run_for(), run_until(), poll() or
+   * poll_one() on the same io_context object may introduce the potential for
+   * deadlock. It is the caller's reponsibility to avoid this.
+   */
+  ASIO_DECL count_type run_one();
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use non-error_code overlaod.) Run the io_context object's
+  /// event processing loop to execute at most one handler.
+  /**
+   * The run_one() function blocks until one handler has been dispatched, or
+   * until the io_context has been stopped.
+   *
+   * @return The number of handlers that were executed. A zero return value
+   * implies that the io_context 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
+   * restart().
+   *
+   * @return The number of handlers that were executed.
+   *
+   * @note Calling the run_one() function from a thread that is currently
+   * calling one of run(), run_one(), run_for(), run_until(), poll() or
+   * poll_one() on the same io_context object may introduce the potential for
+   * deadlock. It is the caller's reponsibility to avoid this.
+   */
+  ASIO_DECL count_type run_one(asio::error_code& ec);
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+#if defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
+  /// Run the io_context object's event processing loop for a specified duration
+  /// to execute at most one handler.
+  /**
+   * The run_one_for() function blocks until one handler has been dispatched,
+   * until the io_context has been stopped, or until the specified duration has
+   * elapsed.
+   *
+   * @param rel_time The duration for which the call may block.
+   *
+   * @return The number of handlers that were executed.
+   */
+  template <typename Rep, typename Period>
+  std::size_t run_one_for(const chrono::duration<Rep, Period>& rel_time);
+
+  /// Run the io_context object's event processing loop until a specified time
+  /// to execute at most one handler.
+  /**
+   * The run_one_until() function blocks until one handler has been dispatched,
+   * until the io_context has been stopped, or until the specified time has
+   * been reached.
+   *
+   * @param abs_time The time point until which the call may block.
+   *
+   * @return The number of handlers that were executed.
+   */
+  template <typename Clock, typename Duration>
+  std::size_t run_one_until(
+      const chrono::time_point<Clock, Duration>& abs_time);
+#endif // defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
+
+  /// Run the io_context object's event processing loop to execute ready
+  /// handlers.
+  /**
+   * The poll() function runs handlers that are ready to run, without blocking,
+   * until the io_context has been stopped or there are no more ready handlers.
+   *
+   * @return The number of handlers that were executed.
+   */
+  ASIO_DECL count_type poll();
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
+  /// event processing loop to execute ready handlers.
+  /**
+   * The poll() function runs handlers that are ready to run, without blocking,
+   * until the io_context has been stopped or there are no more ready handlers.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @return The number of handlers that were executed.
+   */
+  ASIO_DECL count_type poll(asio::error_code& ec);
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Run the io_context object's event processing loop to execute one ready
+  /// handler.
+  /**
+   * The poll_one() function runs at most one handler that is ready to run,
+   * without blocking.
+   *
+   * @return The number of handlers that were executed.
+   */
+  ASIO_DECL count_type poll_one();
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
+  /// event processing loop to execute one ready handler.
+  /**
+   * The poll_one() function runs at most one handler that is ready to run,
+   * without blocking.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @return The number of handlers that were executed.
+   */
+  ASIO_DECL count_type poll_one(asio::error_code& ec);
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Stop the io_context object's event processing loop.
+  /**
+   * This function does not block, but instead simply signals the io_context to
+   * stop. All invocations of its run() or run_one() member functions should
+   * return as soon as possible. Subsequent calls to run(), run_one(), poll()
+   * or poll_one() will return immediately until restart() is called.
+   */
+  ASIO_DECL void stop();
+
+  /// Determine whether the io_context object has been stopped.
+  /**
+   * This function is used to determine whether an io_context object has been
+   * stopped, either through an explicit call to stop(), or due to running out
+   * of work. When an io_context 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_context object is stopped, otherwise @c false.
+   */
+  ASIO_DECL bool stopped() const;
+
+  /// Restart the io_context 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_context
+   * being stopped or running out of work. After a call to restart(), the
+   * io_context 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.
+   */
+  ASIO_DECL void restart();
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use restart().) Reset the io_context 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_context
+   * being stopped or running out of work. After a call to restart(), the
+   * io_context 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.
+   */
+  void reset();
+
+  /// (Deprecated: Use asio::dispatch().) Request the io_context to
+  /// invoke the given handler.
+  /**
+   * This function is used to ask the io_context to execute the given handler.
+   *
+   * The io_context guarantees that the handler will only be called in a thread
+   * in which the run(), run_one(), poll() or poll_one() member functions is
+   * currently being invoked. The handler may be executed inside this function
+   * if the guarantee can be met.
+   *
+   * @param handler The handler to be called. The io_context will make
+   * a copy of the handler object as required. The function signature of the
+   * handler must be: @code void handler(); @endcode
+   *
+   * @note This function throws an exception only if:
+   *
+   * @li the handler's @c asio_handler_allocate function; or
+   *
+   * @li the handler's copy constructor
+   *
+   * throws an exception.
+   */
+  template <typename LegacyCompletionHandler>
+  ASIO_INITFN_RESULT_TYPE(LegacyCompletionHandler, void ())
+  dispatch(ASIO_MOVE_ARG(LegacyCompletionHandler) handler);
+
+  /// (Deprecated: Use asio::post().) Request the io_context to invoke
+  /// the given handler and return immediately.
+  /**
+   * This function is used to ask the io_context to execute the given handler,
+   * but without allowing the io_context to call the handler from inside this
+   * function.
+   *
+   * The io_context guarantees that the handler will only be called in a thread
+   * in which the run(), run_one(), poll() or poll_one() member functions is
+   * currently being invoked.
+   *
+   * @param handler The handler to be called. The io_context will make
+   * a copy of the handler object as required. The function signature of the
+   * handler must be: @code void handler(); @endcode
+   *
+   * @note This function throws an exception only if:
+   *
+   * @li the handler's @c asio_handler_allocate function; or
+   *
+   * @li the handler's copy constructor
+   *
+   * throws an exception.
+   */
+  template <typename LegacyCompletionHandler>
+  ASIO_INITFN_RESULT_TYPE(LegacyCompletionHandler, void ())
+  post(ASIO_MOVE_ARG(LegacyCompletionHandler) handler);
+
+  /// (Deprecated: Use asio::bind_executor().) Create a new handler that
+  /// automatically dispatches the wrapped handler on the io_context.
+  /**
+   * This function is used to create a new handler function object that, when
+   * invoked, will automatically pass the wrapped handler to the io_context
+   * object's dispatch function.
+   *
+   * @param handler The handler to be wrapped. The io_context will make a copy
+   * of the handler object as required. The function signature of the handler
+   * must be: @code void handler(A1 a1, ... An an); @endcode
+   *
+   * @return A function object that, when invoked, passes the wrapped handler to
+   * the io_context object's dispatch function. Given a function object with the
+   * signature:
+   * @code R f(A1 a1, ... An an); @endcode
+   * If this function object is passed to the wrap function like so:
+   * @code io_context.wrap(f); @endcode
+   * then the return value is a function object with the signature
+   * @code void g(A1 a1, ... An an); @endcode
+   * that, when invoked, executes code equivalent to:
+   * @code io_context.dispatch(boost::bind(f, a1, ... an)); @endcode
+   */
+  template <typename Handler>
+#if defined(GENERATING_DOCUMENTATION)
+  unspecified
+#else
+  detail::wrapped_handler<io_context&, Handler>
+#endif
+  wrap(Handler handler);
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+private:
+  // Helper function to add the implementation.
+  ASIO_DECL impl_type& add_impl(impl_type* impl);
+
+  // Backwards compatible overload for use with services derived from
+  // io_context::service.
+  template <typename Service>
+  friend Service& use_service(io_context& ioc);
+
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  detail::winsock_init<> init_;
+#elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
+  || defined(__osf__)
+  detail::signal_init<> init_;
+#endif
+
+  // The implementation.
+  impl_type& impl_;
+};
+
+/// Executor used to submit functions to an io_context.
+class io_context::executor_type
+{
+public:
+  /// Obtain the underlying execution context.
+  io_context& context() const ASIO_NOEXCEPT;
+
+  /// Inform the io_context that it has some outstanding work to do.
+  /**
+   * This function is used to inform the io_context that some work has begun.
+   * This ensures that the io_context's run() and run_one() functions do not
+   * exit while the work is underway.
+   */
+  void on_work_started() const ASIO_NOEXCEPT;
+
+  /// Inform the io_context that some work is no longer outstanding.
+  /**
+   * This function is used to inform the io_context that some work has
+   * finished. Once the count of unfinished work reaches zero, the io_context
+   * is stopped and the run() and run_one() functions may exit.
+   */
+  void on_work_finished() const ASIO_NOEXCEPT;
+
+  /// Request the io_context to invoke the given function object.
+  /**
+   * This function is used to ask the io_context to execute the given function
+   * object. If the current thread is running the io_context, @c dispatch()
+   * executes the function before returning. Otherwise, the function will be
+   * scheduled to run on the io_context.
+   *
+   * @param f The function object to be called. The executor will make a copy
+   * of the handler object as required. The function signature of the function
+   * object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the io_context to invoke the given function object.
+  /**
+   * This function is used to ask the io_context to execute the given function
+   * object. The function object will never be executed inside @c post().
+   * Instead, it will be scheduled to run on the io_context.
+   *
+   * @param f The function object to be called. The executor will make a copy
+   * of the handler object as required. The function signature of the function
+   * object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void post(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the io_context to invoke the given function object.
+  /**
+   * This function is used to ask the io_context to execute the given function
+   * object. The function object will never be executed inside @c defer().
+   * Instead, it will be scheduled to run on the io_context.
+   *
+   * If the current thread belongs to the io_context, @c defer() will delay
+   * scheduling the function object until the current thread returns control to
+   * the pool.
+   *
+   * @param f The function object to be called. The executor will make a copy
+   * of the handler object as required. The function signature of the function
+   * object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void defer(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Determine whether the io_context is running in the current thread.
+  /**
+   * @return @c true if the current thread is running the io_context. Otherwise
+   * returns @c false.
+   */
+  bool running_in_this_thread() const ASIO_NOEXCEPT;
+
+  /// Compare two executors for equality.
+  /**
+   * Two executors are equal if they refer to the same underlying io_context.
+   */
+  friend bool operator==(const executor_type& a,
+      const executor_type& b) ASIO_NOEXCEPT
+  {
+    return &a.io_context_ == &b.io_context_;
+  }
+
+  /// Compare two executors for inequality.
+  /**
+   * Two executors are equal if they refer to the same underlying io_context.
+   */
+  friend bool operator!=(const executor_type& a,
+      const executor_type& b) ASIO_NOEXCEPT
+  {
+    return &a.io_context_ != &b.io_context_;
+  }
+
+private:
+  friend class io_context;
+
+  // Constructor.
+  explicit executor_type(io_context& i) : io_context_(i) {}
+
+  // The underlying io_context.
+  io_context& io_context_;
+};
+
+#if !defined(ASIO_NO_DEPRECATED)
+/// (Deprecated: Use executor_work_guard.) Class to inform the io_context when
+/// it has work to do.
+/**
+ * The work class is used to inform the io_context when work starts and
+ * finishes. This ensures that the io_context object's run() function will not
+ * exit while work is underway, and that it does exit when there is no
+ * unfinished work remaining.
+ *
+ * The work class is copy-constructible so that it may be used as a data member
+ * in a handler class. It is not assignable.
+ */
+class io_context::work
+{
+public:
+  /// Constructor notifies the io_context that work is starting.
+  /**
+   * The constructor is used to inform the io_context that some work has begun.
+   * This ensures that the io_context object's run() function will not exit
+   * while the work is underway.
+   */
+  explicit work(asio::io_context& io_context);
+
+  /// Copy constructor notifies the io_context that work is starting.
+  /**
+   * The constructor is used to inform the io_context that some work has begun.
+   * This ensures that the io_context object's run() function will not exit
+   * while the work is underway.
+   */
+  work(const work& other);
+
+  /// Destructor notifies the io_context that the work is complete.
+  /**
+   * The destructor is used to inform the io_context that some work has
+   * finished. Once the count of unfinished work reaches zero, the io_context
+   * object's run() function is permitted to exit.
+   */
+  ~work();
+
+  /// Get the io_context associated with the work.
+  asio::io_context& get_io_context();
+
+  /// (Deprecated: Use get_io_context().) Get the io_context associated with the
+  /// work.
+  asio::io_context& get_io_service();
+
+private:
+  // Prevent assignment.
+  void operator=(const work& other);
+
+  // The io_context implementation.
+  detail::io_context_impl& io_context_impl_;
+};
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+/// Base class for all io_context services.
+class io_context::service
+  : public execution_context::service
+{
+public:
+  /// Get the io_context object that owns the service.
+  asio::io_context& get_io_context();
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// Get the io_context object that owns the service.
+  asio::io_context& get_io_service();
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+private:
+  /// Destroy all user-defined handler objects owned by the service.
+  ASIO_DECL virtual void shutdown();
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use shutdown().) Destroy all user-defined handler objects
+  /// owned by the service.
+  ASIO_DECL virtual void shutdown_service();
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// 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.
+   */
+  ASIO_DECL virtual void notify_fork(
+      execution_context::fork_event event);
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use notify_fork().) 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.
+   */
+  ASIO_DECL virtual void fork_service(
+      execution_context::fork_event event);
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+protected:
+  /// Constructor.
+  /**
+   * @param owner The io_context object that owns the service.
+   */
+  ASIO_DECL service(asio::io_context& owner);
+
+  /// Destructor.
+  ASIO_DECL virtual ~service();
+};
+
+namespace detail {
+
+// Special service base class to keep classes header-file only.
+template <typename Type>
+class service_base
+  : public asio::io_context::service
+{
+public:
+  static asio::detail::service_id<Type> id;
+
+  // Constructor.
+  service_base(asio::io_context& io_context)
+    : asio::io_context::service(io_context)
+  {
+  }
+};
+
+template <typename Type>
+asio::detail::service_id<Type> service_base<Type>::id;
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/io_context.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/io_context.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+// If both io_context.hpp and strand.hpp have been included, automatically
+// include the header file needed for the io_context::strand class.
+#if !defined(ASIO_NO_EXTENSIONS)
+# if defined(ASIO_STRAND_HPP)
+#  include "asio/io_context_strand.hpp"
+# endif // defined(ASIO_STRAND_HPP)
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
+#endif // ASIO_IO_CONTEXT_HPP
diff --git a/extern/include/asio/io_context_strand.hpp b/extern/include/asio/io_context_strand.hpp
new file mode 100644
index 00000000..3c596f12
--- /dev/null
+++ b/extern/include/asio/io_context_strand.hpp
@@ -0,0 +1,384 @@
+//
+// io_context_strand.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IO_CONTEXT_STRAND_HPP
+#define ASIO_IO_CONTEXT_STRAND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_NO_EXTENSIONS)
+
+#include "asio/async_result.hpp"
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/strand_service.hpp"
+#include "asio/detail/wrapped_handler.hpp"
+#include "asio/io_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// Provides serialised handler execution.
+/**
+ * The io_context::strand class provides the ability to post and dispatch
+ * handlers with the guarantee that none of those handlers will execute
+ * concurrently.
+ *
+ * @par Order of handler invocation
+ * Given:
+ *
+ * @li a strand object @c s
+ *
+ * @li an object @c a meeting completion handler requirements
+ *
+ * @li an object @c a1 which is an arbitrary copy of @c a made by the
+ * implementation
+ *
+ * @li an object @c b meeting completion handler requirements
+ *
+ * @li an object @c b1 which is an arbitrary copy of @c b made by the
+ * implementation
+ *
+ * if any of the following conditions are true:
+ *
+ * @li @c s.post(a) happens-before @c s.post(b)
+ * 
+ * @li @c s.post(a) happens-before @c s.dispatch(b), where the latter is
+ * performed outside the strand
+ * 
+ * @li @c s.dispatch(a) happens-before @c s.post(b), where the former is
+ * performed outside the strand
+ * 
+ * @li @c s.dispatch(a) happens-before @c s.dispatch(b), where both are
+ * performed outside the strand
+ *   
+ * then @c asio_handler_invoke(a1, &a1) happens-before
+ * @c asio_handler_invoke(b1, &b1).
+ * 
+ * Note that in the following case:
+ * @code async_op_1(..., s.wrap(a));
+ * async_op_2(..., s.wrap(b)); @endcode
+ * the completion of the first async operation will perform @c s.dispatch(a),
+ * and the second will perform @c s.dispatch(b), but the order in which those
+ * are performed is unspecified. That is, you cannot state whether one
+ * happens-before the other. Therefore none of the above conditions are met and
+ * no ordering guarantee is made.
+ *
+ * @note The implementation makes no guarantee that handlers posted or
+ * dispatched through different @c strand objects will be invoked concurrently.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Dispatcher.
+ */
+class io_context::strand
+{
+public:
+  /// Constructor.
+  /**
+   * Constructs the strand.
+   *
+   * @param io_context The io_context object that the strand will use to
+   * dispatch handlers that are ready to be run.
+   */
+  explicit strand(asio::io_context& io_context)
+    : service_(asio::use_service<
+        asio::detail::strand_service>(io_context))
+  {
+    service_.construct(impl_);
+  }
+
+  /// Destructor.
+  /**
+   * Destroys a strand.
+   *
+   * Handlers posted through the strand that have not yet been invoked will
+   * still be dispatched in a way that meets the guarantee of non-concurrency.
+   */
+  ~strand()
+  {
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use context().) Get the io_context associated with the
+  /// strand.
+  /**
+   * This function may be used to obtain the io_context object that the strand
+   * uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the strand will use to
+   * dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return service_.get_io_context();
+  }
+
+  /// (Deprecated: Use context().) Get the io_context associated with the
+  /// strand.
+  /**
+   * This function may be used to obtain the io_context object that the strand
+   * uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the strand will use to
+   * dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return service_.get_io_context();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Obtain the underlying execution context.
+  asio::io_context& context() const ASIO_NOEXCEPT
+  {
+    return service_.get_io_context();
+  }
+
+  /// Inform the strand that it has some outstanding work to do.
+  /**
+   * The strand delegates this call to its underlying io_context.
+   */
+  void on_work_started() const ASIO_NOEXCEPT
+  {
+    context().get_executor().on_work_started();
+  }
+
+  /// Inform the strand that some work is no longer outstanding.
+  /**
+   * The strand delegates this call to its underlying io_context.
+   */
+  void on_work_finished() const ASIO_NOEXCEPT
+  {
+    context().get_executor().on_work_finished();
+  }
+
+  /// Request the strand to invoke the given function object.
+  /**
+   * This function is used to ask the strand to execute the given function
+   * object on its underlying io_context. The function object will be executed
+   * inside this function if the strand is not otherwise busy and if the
+   * underlying io_context's executor's @c dispatch() function is also able to
+   * execute the function before returning.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+  {
+    typename decay<Function>::type tmp(ASIO_MOVE_CAST(Function)(f));
+    service_.dispatch(impl_, tmp);
+    (void)a;
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use asio::dispatch().) Request the strand to invoke
+  /// the given handler.
+  /**
+   * This function is used to ask the strand to execute the given handler.
+   *
+   * The strand object guarantees that handlers posted or dispatched through
+   * the strand will not be executed concurrently. The handler may be executed
+   * inside this function if the guarantee can be met. If this function is
+   * called from within a handler that was posted or dispatched through the same
+   * strand, then the new handler will be executed immediately.
+   *
+   * The strand's guarantee is in addition to the guarantee provided by the
+   * underlying io_context. The io_context guarantees that the handler will only
+   * be called in a thread in which the io_context's run member function is
+   * currently being invoked.
+   *
+   * @param handler The handler to be called. The strand will make a copy of the
+   * handler object as required. The function signature of the handler must be:
+   * @code void handler(); @endcode
+   */
+  template <typename LegacyCompletionHandler>
+  ASIO_INITFN_RESULT_TYPE(LegacyCompletionHandler, void ())
+  dispatch(ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a LegacyCompletionHandler.
+    ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
+        LegacyCompletionHandler, handler) type_check;
+
+    async_completion<LegacyCompletionHandler, void ()> init(handler);
+
+    service_.dispatch(impl_, init.completion_handler);
+
+    return init.result.get();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Request the strand to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object will never be executed inside this function.
+   * Instead, it will be scheduled to run by the underlying io_context.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void post(ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+  {
+    typename decay<Function>::type tmp(ASIO_MOVE_CAST(Function)(f));
+    service_.post(impl_, tmp);
+    (void)a;
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use asio::post().) Request the strand to invoke the
+  /// given handler and return immediately.
+  /**
+   * This function is used to ask the strand to execute the given handler, but
+   * without allowing the strand to call the handler from inside this function.
+   *
+   * The strand object guarantees that handlers posted or dispatched through
+   * the strand will not be executed concurrently. The strand's guarantee is in
+   * addition to the guarantee provided by the underlying io_context. The
+   * io_context guarantees that the handler will only be called in a thread in
+   * which the io_context's run member function is currently being invoked.
+   *
+   * @param handler The handler to be called. The strand will make a copy of the
+   * handler object as required. The function signature of the handler must be:
+   * @code void handler(); @endcode
+   */
+  template <typename LegacyCompletionHandler>
+  ASIO_INITFN_RESULT_TYPE(LegacyCompletionHandler, void ())
+  post(ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a LegacyCompletionHandler.
+    ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
+        LegacyCompletionHandler, handler) type_check;
+
+    async_completion<LegacyCompletionHandler, void ()> init(handler);
+
+    service_.post(impl_, init.completion_handler);
+
+    return init.result.get();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Request the strand to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object will never be executed inside this function.
+   * Instead, it will be scheduled to run by the underlying io_context.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void defer(ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+  {
+    typename decay<Function>::type tmp(ASIO_MOVE_CAST(Function)(f));
+    service_.post(impl_, tmp);
+    (void)a;
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use asio::bind_executor().) Create a new handler that
+  /// automatically dispatches the wrapped handler on the strand.
+  /**
+   * This function is used to create a new handler function object that, when
+   * invoked, will automatically pass the wrapped handler to the strand's
+   * dispatch function.
+   *
+   * @param handler The handler to be wrapped. The strand will make a copy of
+   * the handler object as required. The function signature of the handler must
+   * be: @code void handler(A1 a1, ... An an); @endcode
+   *
+   * @return A function object that, when invoked, passes the wrapped handler to
+   * the strand's dispatch function. Given a function object with the signature:
+   * @code R f(A1 a1, ... An an); @endcode
+   * If this function object is passed to the wrap function like so:
+   * @code strand.wrap(f); @endcode
+   * then the return value is a function object with the signature
+   * @code void g(A1 a1, ... An an); @endcode
+   * that, when invoked, executes code equivalent to:
+   * @code strand.dispatch(boost::bind(f, a1, ... an)); @endcode
+   */
+  template <typename Handler>
+#if defined(GENERATING_DOCUMENTATION)
+  unspecified
+#else
+  detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
+#endif
+  wrap(Handler handler)
+  {
+    return detail::wrapped_handler<io_context::strand, Handler,
+        detail::is_continuation_if_running>(*this, handler);
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Determine whether the strand is running in the current thread.
+  /**
+   * @return @c true if the current thread is executing a handler that was
+   * submitted to the strand using post(), dispatch() or wrap(). Otherwise
+   * returns @c false.
+   */
+  bool running_in_this_thread() const ASIO_NOEXCEPT
+  {
+    return service_.running_in_this_thread(impl_);
+  }
+
+  /// Compare two strands for equality.
+  /**
+   * Two strands are equal if they refer to the same ordered, non-concurrent
+   * state.
+   */
+  friend bool operator==(const strand& a, const strand& b) ASIO_NOEXCEPT
+  {
+    return a.impl_ == b.impl_;
+  }
+
+  /// Compare two strands for inequality.
+  /**
+   * Two strands are equal if they refer to the same ordered, non-concurrent
+   * state.
+   */
+  friend bool operator!=(const strand& a, const strand& b) ASIO_NOEXCEPT
+  {
+    return a.impl_ != b.impl_;
+  }
+
+private:
+  asio::detail::strand_service& service_;
+  mutable asio::detail::strand_service::implementation_type impl_;
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
+#endif // ASIO_IO_CONTEXT_STRAND_HPP
diff --git a/extern/include/asio/io_service.hpp b/extern/include/asio/io_service.hpp
index 690f757e..ed05c834 100644
--- a/extern/include/asio/io_service.hpp
+++ b/extern/include/asio/io_service.hpp
@@ -2,7 +2,7 @@
 // io_service.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,756 +15,19 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <stdexcept>
-#include <typeinfo>
-#include "asio/async_result.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/wrapped_handler.hpp"
-#include "asio/error_code.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# include "asio/detail/winsock_init.hpp"
-#elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
-  || defined(__osf__)
-# include "asio/detail/signal_init.hpp"
-#endif
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 
-class io_service;
-template <typename Service> Service& use_service(io_service& ios);
-template <typename Service> void add_service(io_service& ios, Service* svc);
-template <typename Service> bool has_service(io_service& ios);
-
-namespace detail {
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_service io_service_impl;
-  class win_iocp_overlapped_ptr;
-#else
-  typedef class task_io_service io_service_impl;
-#endif
-  class service_registry;
-} // namespace detail
-
-/// Provides core I/O functionality.
-/**
- * The io_service class provides the core I/O functionality for users of the
- * asynchronous I/O objects, including:
- *
- * @li asio::ip::tcp::socket
- * @li asio::ip::tcp::acceptor
- * @li asio::ip::udp::socket
- * @li asio::deadline_timer.
- *
- * The io_service class also includes facilities intended for developers of
- * custom asynchronous services.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @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.
- *
- * @par Synchronous and asynchronous operations
- *
- * Synchronous operations on I/O objects implicitly run the io_service object
- * for an individual operation. The io_service functions run(), run_one(),
- * poll() or poll_one() must be called for the io_service to perform
- * asynchronous operations on behalf of a C++ program. Notification that an
- * asynchronous operation has completed is delivered by invocation of the
- * associated handler. Handlers are invoked only by a thread that is currently
- * calling any overload of run(), run_one(), poll() or poll_one() for the
- * io_service.
- *
- * @par Effect of exceptions thrown from handlers
- *
- * If an exception is thrown from a handler, the exception is allowed to
- * propagate through the throwing thread's invocation of run(), run_one(),
- * poll() or poll_one(). No other threads that are calling any of these
- * functions are affected. It is then the responsibility of the application to
- * catch the exception.
- *
- * After the exception has been caught, the run(), run_one(), poll() or
- * poll_one() call may be restarted @em without the need for an intervening
- * call to reset(). This allows the thread to rejoin the io_service object's
- * thread pool without impacting any other threads in the pool.
- *
- * For example:
- *
- * @code
- * asio::io_service io_service;
- * ...
- * for (;;)
- * {
- *   try
- *   {
- *     io_service.run();
- *     break; // run() exited normally
- *   }
- *   catch (my_exception& e)
- *   {
- *     // Deal with exception as appropriate.
- *   }
- * }
- * @endcode
- *
- * @par Stopping the io_service from running out of work
- *
- * Some applications may need to prevent an io_service object's run() call from
- * returning when there is no more work to do. For example, the io_service may
- * be being run in a background thread that is launched prior to the
- * application's asynchronous operations. The run() call may be kept running by
- * creating an object of type asio::io_service::work:
- *
- * @code asio::io_service io_service;
- * asio::io_service::work work(io_service);
- * ... @endcode
- *
- * To effect a shutdown, the application will then need to call the io_service
- * object's stop() member function. This will cause the io_service run() call
- * to return as soon as possible, abandoning unfinished operations and without
- * permitting ready handlers to be dispatched.
- *
- * Alternatively, if the application requires that all operations and handlers
- * be allowed to finish normally, the work object may be explicitly destroyed.
- *
- * @code asio::io_service io_service;
- * auto_ptr<asio::io_service::work> work(
- *     new asio::io_service::work(io_service));
- * ...
- * work.reset(); // Allow run() to exit. @endcode
- *
- * @par The io_service class and I/O services
- *
- * Class io_service implements an extensible, type-safe, polymorphic set of I/O
- * services, indexed by service type. An object of class io_service must be
- * initialised before I/O objects such as sockets, resolvers and timers can be
- * used. These I/O objects are distinguished by having constructors that accept
- * an @c io_service& parameter.
- *
- * I/O services exist to manage the logical interface to the operating system on
- * behalf of the I/O objects. In particular, there are resources that are shared
- * across a class of I/O objects. For example, timers may be implemented in
- * terms of a single timer queue. The I/O services manage these shared
- * resources.
- *
- * Access to the services of an io_service is via three function templates,
- * use_service(), add_service() and has_service().
- *
- * In a call to @c use_service<Service>(), the type argument chooses a service,
- * making available all members of the named type. If @c Service is not present
- * in an io_service, an object of type @c Service is created and added to the
- * io_service. A C++ program can check if an io_service implements a
- * particular service with the function template @c has_service<Service>().
- *
- * Service objects may be explicitly added to an io_service using the function
- * template @c add_service<Service>(). If the @c Service is already present, the
- * service_already_exists exception is thrown. If the owner of the service is
- * not the same object as the io_service parameter, the invalid_service_owner
- * exception is thrown.
- *
- * Once a service reference is obtained from an io_service object by calling
- * use_service(), that reference remains usable as long as the owning io_service
- * object exists.
- *
- * All I/O service implementations have io_service::service as a public base
- * class. Custom I/O services may be implemented by deriving from this class and
- * then added to an io_service using the facilities described above.
- */
-class io_service
-  : private noncopyable
-{
-private:
-  typedef detail::io_service_impl impl_type;
-#if defined(ASIO_HAS_IOCP)
-  friend class detail::win_iocp_overlapped_ptr;
-#endif
-
-public:
-  class work;
-  friend class work;
-
-  class id;
-
-  class service;
-
-  class strand;
-
-  /// Constructor.
-  ASIO_DECL io_service();
-
-  /// Constructor.
-  /**
-   * Construct with a hint about the required level of concurrency.
-   *
-   * @param concurrency_hint A suggestion to the implementation on how many
-   * threads it should allow to run simultaneously.
-   */
-  ASIO_DECL explicit io_service(std::size_t concurrency_hint);
-
-  /// Destructor.
-  /**
-   * On destruction, the io_service performs the following sequence of
-   * operations:
-   *
-   * @li For each service object @c svc in the io_service set, in reverse order
-   * of the beginning of service object lifetime, performs
-   * @c svc->shutdown_service().
-   *
-   * @li Uninvoked handler objects that were scheduled for deferred invocation
-   * on the io_service, or any associated strand, are destroyed.
-   *
-   * @li For each service object @c svc in the io_service set, in reverse order
-   * of the beginning of service object lifetime, performs
-   * <tt>delete static_cast<io_service::service*>(svc)</tt>.
-   *
-   * @note The destruction sequence described above permits programs to
-   * simplify their resource management by using @c shared_ptr<>. Where an
-   * object's lifetime is tied to the lifetime of a connection (or some other
-   * sequence of asynchronous operations), a @c shared_ptr to the object would
-   * be bound into the handlers for all asynchronous operations associated with
-   * it. This works as follows:
-   *
-   * @li When a single connection ends, all associated asynchronous operations
-   * complete. The corresponding handler objects are destroyed, and all
-   * @c shared_ptr references to the objects are destroyed.
-   *
-   * @li To shut down the whole program, the io_service function stop() is
-   * called to terminate any run() calls as soon as possible. The io_service
-   * destructor defined above destroys all handlers, causing all @c shared_ptr
-   * references to all connection objects to be destroyed.
-   */
-  ASIO_DECL ~io_service();
-
-  /// Run the io_service object's event processing loop.
-  /**
-   * The run() function blocks until all work has finished and there are no
-   * more handlers to be dispatched, or until the io_service has been stopped.
-   *
-   * Multiple threads may call the run() function to set up a pool of threads
-   * from which the io_service may execute handlers. All threads that are
-   * waiting in the pool are equivalent and the io_service may choose any one
-   * of them to invoke a handler.
-   *
-   * 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.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The run() function must not be called from a thread that is currently
-   * calling one of run(), run_one(), poll() or poll_one() on the same
-   * io_service object.
-   *
-   * The poll() function may also be used to dispatch ready handlers, but
-   * without blocking.
-   */
-  ASIO_DECL std::size_t run();
-
-  /// Run the io_service object's event processing loop.
-  /**
-   * The run() function blocks until all work has finished and there are no
-   * more handlers to be dispatched, or until the io_service has been stopped.
-   *
-   * Multiple threads may call the run() function to set up a pool of threads
-   * from which the io_service may execute handlers. All threads that are
-   * waiting in the pool are equivalent and the io_service may choose any one
-   * of them to invoke a handler.
-   *
-   * 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.
-   *
-   * @return The number of handlers that were executed.
-   *
-   * @note The run() function must not be called from a thread that is currently
-   * calling one of run(), run_one(), poll() or poll_one() on the same
-   * io_service object.
-   *
-   * The poll() function may also be used to dispatch ready handlers, but
-   * without blocking.
-   */
-  ASIO_DECL std::size_t run(asio::error_code& ec);
-
-  /// Run the io_service object's event processing loop to execute at most one
-  /// handler.
-  /**
-   * 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. 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 asio::system_error Thrown on failure.
-   */
-  ASIO_DECL std::size_t run_one();
-
-  /// Run the io_service object's event processing loop to execute at most one
-  /// handler.
-  /**
-   * 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. 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.
-   */
-  ASIO_DECL std::size_t run_one(asio::error_code& ec);
-
-  /// Run the io_service object's event processing loop to execute ready
-  /// handlers.
-  /**
-   * The poll() function runs handlers that are ready to run, without blocking,
-   * until the io_service has been stopped or there are no more ready handlers.
-   *
-   * @return The number of handlers that were executed.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  ASIO_DECL std::size_t poll();
-
-  /// Run the io_service object's event processing loop to execute ready
-  /// handlers.
-  /**
-   * The poll() function runs handlers that are ready to run, without blocking,
-   * until the io_service has been stopped or there are no more ready handlers.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of handlers that were executed.
-   */
-  ASIO_DECL std::size_t poll(asio::error_code& ec);
-
-  /// Run the io_service object's event processing loop to execute one ready
-  /// handler.
-  /**
-   * The poll_one() function runs at most one handler that is ready to run,
-   * without blocking.
-   *
-   * @return The number of handlers that were executed.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  ASIO_DECL std::size_t poll_one();
-
-  /// Run the io_service object's event processing loop to execute one ready
-  /// handler.
-  /**
-   * The poll_one() function runs at most one handler that is ready to run,
-   * without blocking.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of handlers that were executed.
-   */
-  ASIO_DECL std::size_t poll_one(asio::error_code& ec);
-
-  /// Stop the io_service object's event processing loop.
-  /**
-   * This function does not block, but instead simply signals the io_service to
-   * stop. All invocations of its run() or run_one() member functions should
-   * return as soon as possible. Subsequent calls to run(), run_one(), poll()
-   * or poll_one() will return immediately until reset() is called.
-   */
-  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.
-   */
-  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. 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.
-   */
-  ASIO_DECL void reset();
-
-  /// Request the io_service to invoke the given handler.
-  /**
-   * This function is used to ask the io_service to execute the given handler.
-   *
-   * The io_service guarantees that the handler will only be called in a thread
-   * in which the run(), run_one(), poll() or poll_one() member functions is
-   * currently being invoked. The handler may be executed inside this function
-   * if the guarantee can be met.
-   *
-   * @param handler The handler to be called. The io_service will make
-   * a copy of the handler object as required. The function signature of the
-   * handler must be: @code void handler(); @endcode
-   *
-   * @note This function throws an exception only if:
-   *
-   * @li the handler's @c asio_handler_allocate function; or
-   *
-   * @li the handler's copy constructor
-   *
-   * throws an exception.
-   */
-  template <typename CompletionHandler>
-  ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
-  dispatch(ASIO_MOVE_ARG(CompletionHandler) handler);
-
-  /// Request the io_service to invoke the given handler and return immediately.
-  /**
-   * This function is used to ask the io_service to execute the given handler,
-   * but without allowing the io_service to call the handler from inside this
-   * function.
-   *
-   * The io_service guarantees that the handler will only be called in a thread
-   * in which the run(), run_one(), poll() or poll_one() member functions is
-   * currently being invoked.
-   *
-   * @param handler The handler to be called. The io_service will make
-   * a copy of the handler object as required. The function signature of the
-   * handler must be: @code void handler(); @endcode
-   *
-   * @note This function throws an exception only if:
-   *
-   * @li the handler's @c asio_handler_allocate function; or
-   *
-   * @li the handler's copy constructor
-   *
-   * throws an exception.
-   */
-  template <typename CompletionHandler>
-  ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
-  post(ASIO_MOVE_ARG(CompletionHandler) handler);
-
-  /// Create a new handler that automatically dispatches the wrapped handler
-  /// on the io_service.
-  /**
-   * This function is used to create a new handler function object that, when
-   * invoked, will automatically pass the wrapped handler to the io_service
-   * object's dispatch function.
-   *
-   * @param handler The handler to be wrapped. The io_service will make a copy
-   * of the handler object as required. The function signature of the handler
-   * must be: @code void handler(A1 a1, ... An an); @endcode
-   *
-   * @return A function object that, when invoked, passes the wrapped handler to
-   * the io_service object's dispatch function. Given a function object with the
-   * signature:
-   * @code R f(A1 a1, ... An an); @endcode
-   * If this function object is passed to the wrap function like so:
-   * @code io_service.wrap(f); @endcode
-   * then the return value is a function object with the signature
-   * @code void g(A1 a1, ... An an); @endcode
-   * that, when invoked, executes code equivalent to:
-   * @code io_service.dispatch(boost::bind(f, a1, ... an)); @endcode
-   */
-  template <typename Handler>
-#if defined(GENERATING_DOCUMENTATION)
-  unspecified
-#else
-  detail::wrapped_handler<io_service&, Handler>
-#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 asio::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(asio::io_service::fork_prepare);
-   * if (fork() == 0)
-   * {
-   *   // This is the child process.
-   *   my_io_service.notify_fork(asio::io_service::fork_child);
-   * }
-   * else
-   * {
-   *   // This is the parent process.
-   *   my_io_service.notify_fork(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.
-   */
-  ASIO_DECL void notify_fork(asio::io_service::fork_event event);
+#if !defined(ASIO_NO_DEPRECATED)
+/// Typedef for backwards compatibility.
+typedef io_context io_service;
+#endif // !defined(ASIO_NO_DEPRECATED)
 
-  /// Obtain the service object corresponding to the given type.
-  /**
-   * This function is used to locate a service object that corresponds to
-   * the given service type. If there is no existing implementation of the
-   * service, then the io_service will create a new instance of the service.
-   *
-   * @param ios The io_service object that owns the service.
-   *
-   * @return The service interface implementing the specified service type.
-   * Ownership of the service interface is not transferred to the caller.
-   */
-  template <typename Service>
-  friend Service& use_service(io_service& ios);
-
-  /// Add a service object to the io_service.
-  /**
-   * This function is used to add a service to the io_service.
-   *
-   * @param ios The io_service object that owns the service.
-   *
-   * @param svc The service object. On success, ownership of the service object
-   * is transferred to the io_service. When the io_service object is destroyed,
-   * it will destroy the service object by performing:
-   * @code delete static_cast<io_service::service*>(svc) @endcode
-   *
-   * @throws asio::service_already_exists Thrown if a service of the
-   * given type is already present in the io_service.
-   *
-   * @throws asio::invalid_service_owner Thrown if the service's owning
-   * io_service is not the io_service object specified by the ios parameter.
-   */
-  template <typename Service>
-  friend void add_service(io_service& ios, Service* svc);
-
-  /// Determine if an io_service contains a specified service type.
-  /**
-   * This function is used to determine whether the io_service contains a
-   * service object corresponding to the given service type.
-   *
-   * @param ios The io_service object that owns the service.
-   *
-   * @return A boolean indicating whether the io_service contains the service.
-   */
-  template <typename Service>
-  friend bool has_service(io_service& ios);
-
-private:
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  detail::winsock_init<> init_;
-#elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
-  || defined(__osf__)
-  detail::signal_init<> init_;
-#endif
-
-  // The service registry.
-  asio::detail::service_registry* service_registry_;
-
-  // The implementation.
-  impl_type& impl_;
-};
-
-/// Class to inform the io_service when it has work to do.
-/**
- * The work class is used to inform the io_service when work starts and
- * finishes. This ensures that the io_service object's run() function will not
- * exit while work is underway, and that it does exit when there is no
- * unfinished work remaining.
- *
- * The work class is copy-constructible so that it may be used as a data member
- * in a handler class. It is not assignable.
- */
-class io_service::work
-{
-public:
-  /// Constructor notifies the io_service that work is starting.
-  /**
-   * The constructor is used to inform the io_service that some work has begun.
-   * This ensures that the io_service object's run() function will not exit
-   * while the work is underway.
-   */
-  explicit work(asio::io_service& io_service);
-
-  /// Copy constructor notifies the io_service that work is starting.
-  /**
-   * The constructor is used to inform the io_service that some work has begun.
-   * This ensures that the io_service object's run() function will not exit
-   * while the work is underway.
-   */
-  work(const work& other);
-
-  /// Destructor notifies the io_service that the work is complete.
-  /**
-   * The destructor is used to inform the io_service that some work has
-   * finished. Once the count of unfinished work reaches zero, the io_service
-   * object's run() function is permitted to exit.
-   */
-  ~work();
-
-  /// Get the io_service associated with the work.
-  asio::io_service& get_io_service();
-
-private:
-  // Prevent assignment.
-  void operator=(const work& other);
-
-  // The io_service implementation.
-  detail::io_service_impl& io_service_impl_;
-};
-
-/// Class used to uniquely identify a service.
-class io_service::id
-  : private noncopyable
-{
-public:
-  /// Constructor.
-  id() {}
-};
-
-/// Base class for all io_service services.
-class io_service::service
-  : private noncopyable
-{
-public:
-  /// Get the io_service object that owns the service.
-  asio::io_service& get_io_service();
-
-protected:
-  /// Constructor.
-  /**
-   * @param owner The io_service object that owns the service.
-   */
-  ASIO_DECL service(asio::io_service& owner);
-
-  /// Destructor.
-  ASIO_DECL virtual ~service();
-
-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.
-   */
-  ASIO_DECL virtual void fork_service(
-      asio::io_service::fork_event event);
-
-  friend class asio::detail::service_registry;
-  struct key
-  {
-    key() : type_info_(0), id_(0) {}
-    const std::type_info* type_info_;
-    const asio::io_service::id* id_;
-  } key_;
-
-  asio::io_service& owner_;
-  service* next_;
-};
-
-/// Exception thrown when trying to add a duplicate service to an io_service.
-class service_already_exists
-  : public std::logic_error
-{
-public:
-  ASIO_DECL service_already_exists();
-};
-
-/// Exception thrown when trying to add a service object to an io_service where
-/// the service has a different owner.
-class invalid_service_owner
-  : public std::logic_error
-{
-public:
-  ASIO_DECL invalid_service_owner();
-};
-
-namespace detail {
-
-// Special derived service id type to keep classes header-file only.
-template <typename Type>
-class service_id
-  : public asio::io_service::id
-{
-};
-
-// Special service base class to keep classes header-file only.
-template <typename Type>
-class service_base
-  : public asio::io_service::service
-{
-public:
-  static asio::detail::service_id<Type> id;
-
-  // Constructor.
-  service_base(asio::io_service& io_service)
-    : asio::io_service::service(io_service)
-  {
-  }
-};
-
-template <typename Type>
-asio::detail::service_id<Type> service_base<Type>::id;
-
-} // namespace detail
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
-#include "asio/impl/io_service.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/io_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
 #endif // ASIO_IO_SERVICE_HPP
diff --git a/extern/include/asio/io_service_strand.hpp b/extern/include/asio/io_service_strand.hpp
new file mode 100644
index 00000000..7093f0e9
--- /dev/null
+++ b/extern/include/asio/io_service_strand.hpp
@@ -0,0 +1,20 @@
+//
+// io_service_strand.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IO_SERVICE_STRAND_HPP
+#define ASIO_IO_SERVICE_STRAND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/io_context_strand.hpp"
+
+#endif // ASIO_IO_SERVICE_STRAND_HPP
diff --git a/extern/include/asio/ip/address.hpp b/extern/include/asio/ip/address.hpp
index 05896b83..cf852a6d 100644
--- a/extern/include/asio/ip/address.hpp
+++ b/extern/include/asio/ip/address.hpp
@@ -2,7 +2,7 @@
 // ip/address.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,13 @@
 
 #include "asio/detail/config.hpp"
 #include <string>
+#include "asio/detail/throw_exception.hpp"
+#include "asio/detail/string_view.hpp"
+#include "asio/detail/type_traits.hpp"
 #include "asio/error_code.hpp"
 #include "asio/ip/address_v4.hpp"
 #include "asio/ip/address_v6.hpp"
+#include "asio/ip/bad_address_cast.hpp"
 
 #if !defined(ASIO_NO_IOSTREAM)
 # include <iosfwd>
@@ -93,29 +97,34 @@ class address
   /// Get the address as an IP version 6 address.
   ASIO_DECL asio::ip::address_v6 to_v6() const;
 
-  /// Get the address as a string in dotted decimal format.
+  /// Get the address as a string.
   ASIO_DECL std::string to_string() const;
 
-  /// Get the address as a string in dotted decimal format.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use other overload.) Get the address as a string.
   ASIO_DECL std::string to_string(asio::error_code& ec) const;
 
-  /// Create an address from an IPv4 address string in dotted decimal form,
-  /// or from an IPv6 address in hexadecimal notation.
-  ASIO_DECL static address from_string(const char* str);
-
-  /// Create an address from an IPv4 address string in dotted decimal form,
-  /// or from an IPv6 address in hexadecimal notation.
-  ASIO_DECL static address from_string(
-      const char* str, asio::error_code& ec);
-
-  /// Create an address from an IPv4 address string in dotted decimal form,
-  /// or from an IPv6 address in hexadecimal notation.
-  ASIO_DECL static address from_string(const std::string& str);
-
-  /// Create an address from an IPv4 address string in dotted decimal form,
-  /// or from an IPv6 address in hexadecimal notation.
-  ASIO_DECL static address from_string(
+  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
+  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
+  /// notation.
+  static address from_string(const char* str);
+
+  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
+  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
+  /// notation.
+  static address from_string(const char* str, asio::error_code& ec);
+
+  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
+  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
+  /// notation.
+  static address from_string(const std::string& str);
+
+  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
+  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
+  /// notation.
+  static address from_string(
       const std::string& str, asio::error_code& ec);
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Determine whether the address is a loopback address.
   ASIO_DECL bool is_loopback() const;
@@ -167,6 +176,57 @@ class address
   asio::ip::address_v6 ipv6_address_;
 };
 
+/// Create an address from an IPv4 address string in dotted decimal form,
+/// or from an IPv6 address in hexadecimal notation.
+/**
+ * @relates address
+ */
+ASIO_DECL address make_address(const char* str);
+
+/// Create an address from an IPv4 address string in dotted decimal form,
+/// or from an IPv6 address in hexadecimal notation.
+/**
+ * @relates address
+ */
+ASIO_DECL address make_address(
+    const char* str, asio::error_code& ec);
+
+/// Create an address from an IPv4 address string in dotted decimal form,
+/// or from an IPv6 address in hexadecimal notation.
+/**
+ * @relates address
+ */
+ASIO_DECL address make_address(const std::string& str);
+
+/// Create an address from an IPv4 address string in dotted decimal form,
+/// or from an IPv6 address in hexadecimal notation.
+/**
+ * @relates address
+ */
+ASIO_DECL address make_address(
+    const std::string& str, asio::error_code& ec);
+
+#if defined(ASIO_HAS_STRING_VIEW) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Create an address from an IPv4 address string in dotted decimal form,
+/// or from an IPv6 address in hexadecimal notation.
+/**
+ * @relates address
+ */
+ASIO_DECL address make_address(string_view str);
+
+/// Create an address from an IPv4 address string in dotted decimal form,
+/// or from an IPv6 address in hexadecimal notation.
+/**
+ * @relates address
+ */
+ASIO_DECL address make_address(
+    string_view str, asio::error_code& ec);
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+       //  || defined(GENERATING_DOCUMENTATION)
+
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Output an address as a string.
diff --git a/extern/include/asio/ip/address_v4.hpp b/extern/include/asio/ip/address_v4.hpp
index 451afcc6..4e1cc9a3 100644
--- a/extern/include/asio/ip/address_v4.hpp
+++ b/extern/include/asio/ip/address_v4.hpp
@@ -2,7 +2,7 @@
 // ip/address_v4.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,7 +18,9 @@
 #include "asio/detail/config.hpp"
 #include <string>
 #include "asio/detail/array.hpp"
+#include "asio/detail/cstdint.hpp"
 #include "asio/detail/socket_types.hpp"
+#include "asio/detail/string_view.hpp"
 #include "asio/detail/winsock_init.hpp"
 #include "asio/error_code.hpp"
 
@@ -43,6 +45,9 @@ namespace ip {
 class address_v4
 {
 public:
+  /// The type used to represent an address as an unsigned integer.
+  typedef uint_least32_t uint_type;
+
   /// The type used to represent an address as an array of bytes.
   /**
    * @note This type is defined in terms of the C++0x template @c std::array
@@ -63,8 +68,8 @@ class address_v4
   /// Construct an address from raw bytes.
   ASIO_DECL explicit address_v4(const bytes_type& bytes);
 
-  /// Construct an address from a unsigned long in host byte order.
-  ASIO_DECL explicit address_v4(unsigned long addr);
+  /// Construct an address from an unsigned integer in host byte order.
+  ASIO_DECL explicit address_v4(uint_type addr);
 
   /// Copy constructor.
   address_v4(const address_v4& other)
@@ -99,28 +104,40 @@ class address_v4
   /// Get the address in bytes, in network byte order.
   ASIO_DECL bytes_type to_bytes() const;
 
+  /// Get the address as an unsigned integer in host byte order
+  ASIO_DECL uint_type to_uint() const;
+
+#if !defined(ASIO_NO_DEPRECATED)
   /// Get the address as an unsigned long in host byte order
   ASIO_DECL unsigned long to_ulong() const;
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Get the address as a string in dotted decimal format.
   ASIO_DECL std::string to_string() const;
 
-  /// Get the address as a string in dotted decimal format.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use other overload.) Get the address as a string in dotted
+  /// decimal format.
   ASIO_DECL std::string to_string(asio::error_code& ec) const;
 
-  /// Create an address from an IP address string in dotted decimal form.
-  ASIO_DECL static address_v4 from_string(const char* str);
+  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
+  /// string in dotted decimal form.
+  static address_v4 from_string(const char* str);
 
-  /// Create an address from an IP address string in dotted decimal form.
-  ASIO_DECL static address_v4 from_string(
+  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
+  /// string in dotted decimal form.
+  static address_v4 from_string(
       const char* str, asio::error_code& ec);
 
-  /// Create an address from an IP address string in dotted decimal form.
-  ASIO_DECL static address_v4 from_string(const std::string& str);
+  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
+  /// string in dotted decimal form.
+  static address_v4 from_string(const std::string& str);
 
-  /// Create an address from an IP address string in dotted decimal form.
-  ASIO_DECL static address_v4 from_string(
+  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
+  /// string in dotted decimal form.
+  static address_v4 from_string(
       const std::string& str, asio::error_code& ec);
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Determine whether the address is a loopback address.
   ASIO_DECL bool is_loopback() const;
@@ -128,14 +145,19 @@ class address_v4
   /// Determine whether the address is unspecified.
   ASIO_DECL bool is_unspecified() const;
 
-  /// Determine whether the address is a class A address.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use network_v4 class.) Determine whether the address is a
+  /// class A address.
   ASIO_DECL bool is_class_a() const;
 
-  /// Determine whether the address is a class B address.
+  /// (Deprecated: Use network_v4 class.) Determine whether the address is a
+  /// class B address.
   ASIO_DECL bool is_class_b() const;
 
-  /// Determine whether the address is a class C address.
+  /// (Deprecated: Use network_v4 class.) Determine whether the address is a
+  /// class C address.
   ASIO_DECL bool is_class_c() const;
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Determine whether the address is a multicast address.
   ASIO_DECL bool is_multicast() const;
@@ -155,25 +177,25 @@ class address_v4
   /// Compare addresses for ordering.
   friend bool operator<(const address_v4& a1, const address_v4& a2)
   {
-    return a1.to_ulong() < a2.to_ulong();
+    return a1.to_uint() < a2.to_uint();
   }
 
   /// Compare addresses for ordering.
   friend bool operator>(const address_v4& a1, const address_v4& a2)
   {
-    return a1.to_ulong() > a2.to_ulong();
+    return a1.to_uint() > a2.to_uint();
   }
 
   /// Compare addresses for ordering.
   friend bool operator<=(const address_v4& a1, const address_v4& a2)
   {
-    return a1.to_ulong() <= a2.to_ulong();
+    return a1.to_uint() <= a2.to_uint();
   }
 
   /// Compare addresses for ordering.
   friend bool operator>=(const address_v4& a1, const address_v4& a2)
   {
-    return a1.to_ulong() >= a2.to_ulong();
+    return a1.to_uint() >= a2.to_uint();
   }
 
   /// Obtain an address object that represents any address.
@@ -194,20 +216,86 @@ class address_v4
     return address_v4(0xFFFFFFFF);
   }
 
-  /// Obtain an address object that represents the broadcast address that
-  /// corresponds to the specified address and netmask.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use network_v4 class.) Obtain an address object that
+  /// represents the broadcast address that corresponds to the specified
+  /// address and netmask.
   ASIO_DECL static address_v4 broadcast(
       const address_v4& addr, const address_v4& mask);
 
-  /// Obtain the netmask that corresponds to the address, based on its address
-  /// class.
+  /// (Deprecated: Use network_v4 class.) Obtain the netmask that corresponds
+  /// to the address, based on its address class.
   ASIO_DECL static address_v4 netmask(const address_v4& addr);
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 private:
   // The underlying IPv4 address.
   asio::detail::in4_addr_type addr_;
 };
 
+/// Create an IPv4 address from raw bytes in network order.
+/**
+ * @relates address_v4
+ */
+inline address_v4 make_address_v4(const address_v4::bytes_type& bytes)
+{
+  return address_v4(bytes);
+}
+
+/// Create an IPv4 address from an unsigned integer in host byte order.
+/**
+ * @relates address_v4
+ */
+inline address_v4 make_address_v4(address_v4::uint_type addr)
+{
+  return address_v4(addr);
+}
+
+/// Create an IPv4 address from an IP address string in dotted decimal form.
+/**
+ * @relates address_v4
+ */
+ASIO_DECL address_v4 make_address_v4(const char* str);
+
+/// Create an IPv4 address from an IP address string in dotted decimal form.
+/**
+ * @relates address_v4
+ */
+ASIO_DECL address_v4 make_address_v4(
+    const char* str, asio::error_code& ec);
+
+/// Create an IPv4 address from an IP address string in dotted decimal form.
+/**
+ * @relates address_v4
+ */
+ASIO_DECL address_v4 make_address_v4(const std::string& str);
+
+/// Create an IPv4 address from an IP address string in dotted decimal form.
+/**
+ * @relates address_v4
+ */
+ASIO_DECL address_v4 make_address_v4(
+    const std::string& str, asio::error_code& ec);
+
+#if defined(ASIO_HAS_STRING_VIEW) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Create an IPv4 address from an IP address string in dotted decimal form.
+/**
+ * @relates address_v4
+ */
+ASIO_DECL address_v4 make_address_v4(string_view str);
+
+/// Create an IPv4 address from an IP address string in dotted decimal form.
+/**
+ * @relates address_v4
+ */
+ASIO_DECL address_v4 make_address_v4(
+    string_view str, asio::error_code& ec);
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+       //  || defined(GENERATING_DOCUMENTATION)
+
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Output an address as a string.
diff --git a/extern/include/asio/ip/address_v4_iterator.hpp b/extern/include/asio/ip/address_v4_iterator.hpp
new file mode 100644
index 00000000..e2ef3937
--- /dev/null
+++ b/extern/include/asio/ip/address_v4_iterator.hpp
@@ -0,0 +1,162 @@
+//
+// ip/address_v4_iterator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_ADDRESS_V4_ITERATOR_HPP
+#define ASIO_IP_ADDRESS_V4_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/ip/address_v4.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename> class basic_address_iterator;
+
+/// An input iterator that can be used for traversing IPv4 addresses.
+/**
+ * In addition to satisfying the input iterator requirements, this iterator
+ * also supports decrement.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <> class basic_address_iterator<address_v4>
+{
+public:
+  /// The type of the elements pointed to by the iterator.
+  typedef address_v4 value_type;
+
+  /// Distance between two iterators.
+  typedef std::ptrdiff_t difference_type;
+
+  /// The type of a pointer to an element pointed to by the iterator.
+  typedef const address_v4* pointer;
+
+  /// The type of a reference to an element pointed to by the iterator.
+  typedef const address_v4& reference;
+
+  /// Denotes that the iterator satisfies the input iterator requirements.
+  typedef std::input_iterator_tag iterator_category;
+
+  /// Construct an iterator that points to the specified address.
+  basic_address_iterator(const address_v4& addr) ASIO_NOEXCEPT
+    : address_(addr)
+  {
+  }
+
+  /// Copy constructor.
+  basic_address_iterator(
+      const basic_address_iterator& other) ASIO_NOEXCEPT
+    : address_(other.address_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move constructor.
+  basic_address_iterator(basic_address_iterator&& other) ASIO_NOEXCEPT
+    : address_(ASIO_MOVE_CAST(address_v4)(other.address_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Assignment operator.
+  basic_address_iterator& operator=(
+      const basic_address_iterator& other) ASIO_NOEXCEPT
+  {
+    address_ = other.address_;
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move assignment operator.
+  basic_address_iterator& operator=(
+      basic_address_iterator&& other) ASIO_NOEXCEPT
+  {
+    address_ = ASIO_MOVE_CAST(address_v4)(other.address_);
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Dereference the iterator.
+  const address_v4& operator*() const ASIO_NOEXCEPT
+  {
+    return address_;
+  }
+
+  /// Dereference the iterator.
+  const address_v4* operator->() const ASIO_NOEXCEPT
+  {
+    return &address_;
+  }
+
+  /// Pre-increment operator.
+  basic_address_iterator& operator++() ASIO_NOEXCEPT
+  {
+    address_ = address_v4((address_.to_uint() + 1) & 0xFFFFFFFF);
+    return *this;
+  }
+
+  /// Post-increment operator.
+  basic_address_iterator operator++(int) ASIO_NOEXCEPT
+  {
+    basic_address_iterator tmp(*this);
+    ++*this;
+    return tmp;
+  }
+
+  /// Pre-decrement operator.
+  basic_address_iterator& operator--() ASIO_NOEXCEPT
+  {
+    address_ = address_v4((address_.to_uint() - 1) & 0xFFFFFFFF);
+    return *this;
+  }
+
+  /// Post-decrement operator.
+  basic_address_iterator operator--(int)
+  {
+    basic_address_iterator tmp(*this);
+    --*this;
+    return tmp;
+  }
+
+  /// Compare two addresses for equality.
+  friend bool operator==(const basic_address_iterator& a,
+      const basic_address_iterator& b)
+  {
+    return a.address_ == b.address_;
+  }
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const basic_address_iterator& a,
+      const basic_address_iterator& b)
+  {
+    return a.address_ != b.address_;
+  }
+
+private:
+  address_v4 address_;
+};
+
+/// An input iterator that can be used for traversing IPv4 addresses.
+typedef basic_address_iterator<address_v4> address_v4_iterator;
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_ADDRESS_V4_ITERATOR_HPP
diff --git a/extern/include/asio/ip/address_v4_range.hpp b/extern/include/asio/ip/address_v4_range.hpp
new file mode 100644
index 00000000..a4028420
--- /dev/null
+++ b/extern/include/asio/ip/address_v4_range.hpp
@@ -0,0 +1,134 @@
+//
+// ip/address_v4_range.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_ADDRESS_V4_RANGE_HPP
+#define ASIO_IP_ADDRESS_V4_RANGE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/ip/address_v4_iterator.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename> class basic_address_range;
+
+/// Represents a range of IPv4 addresses.
+/**
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <> class basic_address_range<address_v4>
+{
+public:
+  /// The type of an iterator that points into the range.
+  typedef basic_address_iterator<address_v4> iterator;
+
+  /// Construct an empty range.
+  basic_address_range() ASIO_NOEXCEPT
+    : begin_(address_v4()),
+      end_(address_v4())
+  {
+  }
+
+  /// Construct an range that represents the given range of addresses.
+  explicit basic_address_range(const iterator& first,
+      const iterator& last) ASIO_NOEXCEPT
+    : begin_(first),
+      end_(last)
+  {
+  }
+
+  /// Copy constructor.
+  basic_address_range(const basic_address_range& other) ASIO_NOEXCEPT
+    : begin_(other.begin_),
+      end_(other.end_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move constructor.
+  basic_address_range(basic_address_range&& other) ASIO_NOEXCEPT
+    : begin_(ASIO_MOVE_CAST(iterator)(other.begin_)),
+      end_(ASIO_MOVE_CAST(iterator)(other.end_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Assignment operator.
+  basic_address_range& operator=(
+      const basic_address_range& other) ASIO_NOEXCEPT
+  {
+    begin_ = other.begin_;
+    end_ = other.end_;
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move assignment operator.
+  basic_address_range& operator=(
+      basic_address_range&& other) ASIO_NOEXCEPT
+  {
+    begin_ = ASIO_MOVE_CAST(iterator)(other.begin_);
+    end_ = ASIO_MOVE_CAST(iterator)(other.end_);
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Obtain an iterator that points to the start of the range.
+  iterator begin() const ASIO_NOEXCEPT
+  {
+    return begin_;
+  }
+
+  /// Obtain an iterator that points to the end of the range.
+  iterator end() const ASIO_NOEXCEPT
+  {
+    return end_;
+  }
+
+  /// Determine whether the range is empty.
+  bool empty() const ASIO_NOEXCEPT
+  {
+    return size() == 0;
+  }
+
+  /// Return the size of the range.
+  std::size_t size() const ASIO_NOEXCEPT
+  {
+    return end_->to_uint() - begin_->to_uint();
+  }
+
+  /// Find an address in the range.
+  iterator find(const address_v4& addr) const ASIO_NOEXCEPT
+  {
+    return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
+  }
+
+private:
+  iterator begin_;
+  iterator end_;
+};
+
+/// Represents a range of IPv4 addresses.
+typedef basic_address_range<address_v4> address_v4_range;
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_ADDRESS_V4_RANGE_HPP
diff --git a/extern/include/asio/ip/address_v6.hpp b/extern/include/asio/ip/address_v6.hpp
index 9823d16d..fece3329 100644
--- a/extern/include/asio/ip/address_v6.hpp
+++ b/extern/include/asio/ip/address_v6.hpp
@@ -2,7 +2,7 @@
 // ip/address_v6.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,7 @@
 #include <string>
 #include "asio/detail/array.hpp"
 #include "asio/detail/socket_types.hpp"
+#include "asio/detail/string_view.hpp"
 #include "asio/detail/winsock_init.hpp"
 #include "asio/error_code.hpp"
 #include "asio/ip/address_v4.hpp"
@@ -32,6 +33,8 @@
 namespace asio {
 namespace ip {
 
+template <typename> class basic_address_iterator;
+
 /// Implements IP version 6 style addresses.
 /**
  * The asio::ip::address_v6 class provides the ability to use and
@@ -102,25 +105,32 @@ class address_v6
   /// Get the address as a string.
   ASIO_DECL std::string to_string() const;
 
-  /// Get the address as a string.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use other overload.) Get the address as a string.
   ASIO_DECL std::string to_string(asio::error_code& ec) const;
 
-  /// Create an address from an IP address string.
-  ASIO_DECL static address_v6 from_string(const char* str);
+  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
+  /// address string.
+  static address_v6 from_string(const char* str);
 
-  /// Create an address from an IP address string.
-  ASIO_DECL static address_v6 from_string(
+  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
+  /// address string.
+  static address_v6 from_string(
       const char* str, asio::error_code& ec);
 
-  /// Create an address from an IP address string.
-  ASIO_DECL static address_v6 from_string(const std::string& str);
+  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
+  /// address string.
+  static address_v6 from_string(const std::string& str);
 
-  /// Create an address from an IP address string.
-  ASIO_DECL static address_v6 from_string(
+  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
+  /// address string.
+  static address_v6 from_string(
       const std::string& str, asio::error_code& ec);
 
-  /// Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address.
+  /// (Deprecated: Use make_address_v4().) Converts an IPv4-mapped or
+  /// IPv4-compatible address to an IPv4 address.
   ASIO_DECL address_v4 to_v4() const;
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Determine whether the address is a loopback address.
   ASIO_DECL bool is_loopback() const;
@@ -137,8 +147,11 @@ class address_v6
   /// Determine whether the address is a mapped IPv4 address.
   ASIO_DECL bool is_v4_mapped() const;
 
-  /// Determine whether the address is an IPv4-compatible address.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: No replacement.) Determine whether the address is an
+  /// IPv4-compatible address.
   ASIO_DECL bool is_v4_compatible() const;
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Determine whether the address is a multicast address.
   ASIO_DECL bool is_multicast() const;
@@ -199,13 +212,17 @@ class address_v6
   /// Obtain an address object that represents the loopback address.
   ASIO_DECL static address_v6 loopback();
 
-  /// Create an IPv4-mapped IPv6 address.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use make_address_v6().) Create an IPv4-mapped IPv6 address.
   ASIO_DECL static address_v6 v4_mapped(const address_v4& addr);
 
-  /// Create an IPv4-compatible IPv6 address.
+  /// (Deprecated: No replacement.) Create an IPv4-compatible IPv6 address.
   ASIO_DECL static address_v6 v4_compatible(const address_v4& addr);
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 private:
+  friend class basic_address_iterator<address_v6>;
+
   // The underlying IPv6 address.
   asio::detail::in6_addr_type addr_;
 
@@ -213,6 +230,79 @@ class address_v6
   unsigned long scope_id_;
 };
 
+/// Create an IPv6 address from raw bytes and scope ID.
+/**
+ * @relates address_v6
+ */
+inline address_v6 make_address_v6(const address_v6::bytes_type& bytes,
+    unsigned long scope_id = 0)
+{
+  return address_v6(bytes, scope_id);
+}
+
+/// Create an IPv6 address from an IP address string.
+/**
+ * @relates address_v6
+ */
+ASIO_DECL address_v6 make_address_v6(const char* str);
+
+/// Create an IPv6 address from an IP address string.
+/**
+ * @relates address_v6
+ */
+ASIO_DECL address_v6 make_address_v6(
+    const char* str, asio::error_code& ec);
+
+/// Createan IPv6 address from an IP address string.
+/**
+ * @relates address_v6
+ */
+ASIO_DECL address_v6 make_address_v6(const std::string& str);
+
+/// Create an IPv6 address from an IP address string.
+/**
+ * @relates address_v6
+ */
+ASIO_DECL address_v6 make_address_v6(
+    const std::string& str, asio::error_code& ec);
+
+#if defined(ASIO_HAS_STRING_VIEW) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Create an IPv6 address from an IP address string.
+/**
+ * @relates address_v6
+ */
+ASIO_DECL address_v6 make_address_v6(string_view str);
+
+/// Create an IPv6 address from an IP address string.
+/**
+ * @relates address_v6
+ */
+ASIO_DECL address_v6 make_address_v6(
+    string_view str, asio::error_code& ec);
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+       //  || defined(GENERATING_DOCUMENTATION)
+
+/// Tag type used for distinguishing overloads that deal in IPv4-mapped IPv6
+/// addresses.
+enum v4_mapped_t { v4_mapped };
+
+/// Create an IPv4 address from a IPv4-mapped IPv6 address.
+/**
+ * @relates address_v4
+ */
+ASIO_DECL address_v4 make_address_v4(
+    v4_mapped_t, const address_v6& v6_addr);
+
+/// Create an IPv4-mapped IPv6 address from an IPv4 address.
+/**
+ * @relates address_v6
+ */
+ASIO_DECL address_v6 make_address_v6(
+    v4_mapped_t, const address_v4& v4_addr);
+
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Output an address as a string.
diff --git a/extern/include/asio/ip/address_v6_iterator.hpp b/extern/include/asio/ip/address_v6_iterator.hpp
new file mode 100644
index 00000000..0a1fb3fe
--- /dev/null
+++ b/extern/include/asio/ip/address_v6_iterator.hpp
@@ -0,0 +1,183 @@
+//
+// ip/address_v6_iterator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//                         Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_ADDRESS_V6_ITERATOR_HPP
+#define ASIO_IP_ADDRESS_V6_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/ip/address_v6.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename> class basic_address_iterator;
+
+/// An input iterator that can be used for traversing IPv6 addresses.
+/**
+ * In addition to satisfying the input iterator requirements, this iterator
+ * also supports decrement.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <> class basic_address_iterator<address_v6>
+{
+public:
+  /// The type of the elements pointed to by the iterator.
+  typedef address_v6 value_type;
+
+  /// Distance between two iterators.
+  typedef std::ptrdiff_t difference_type;
+
+  /// The type of a pointer to an element pointed to by the iterator.
+  typedef const address_v6* pointer;
+
+  /// The type of a reference to an element pointed to by the iterator.
+  typedef const address_v6& reference;
+
+  /// Denotes that the iterator satisfies the input iterator requirements.
+  typedef std::input_iterator_tag iterator_category;
+
+  /// Construct an iterator that points to the specified address.
+  basic_address_iterator(const address_v6& addr) ASIO_NOEXCEPT
+    : address_(addr)
+  {
+  }
+
+  /// Copy constructor.
+  basic_address_iterator(
+      const basic_address_iterator& other) ASIO_NOEXCEPT
+    : address_(other.address_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move constructor.
+  basic_address_iterator(basic_address_iterator&& other) ASIO_NOEXCEPT
+    : address_(ASIO_MOVE_CAST(address_v6)(other.address_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Assignment operator.
+  basic_address_iterator& operator=(
+      const basic_address_iterator& other) ASIO_NOEXCEPT
+  {
+    address_ = other.address_;
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move assignment operator.
+  basic_address_iterator& operator=(
+      basic_address_iterator&& other) ASIO_NOEXCEPT
+  {
+    address_ = ASIO_MOVE_CAST(address_v6)(other.address_);
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Dereference the iterator.
+  const address_v6& operator*() const ASIO_NOEXCEPT
+  {
+    return address_;
+  }
+
+  /// Dereference the iterator.
+  const address_v6* operator->() const ASIO_NOEXCEPT
+  {
+    return &address_;
+  }
+
+  /// Pre-increment operator.
+  basic_address_iterator& operator++() ASIO_NOEXCEPT
+  {
+    for (int i = 15; i >= 0; --i)
+    {
+      if (address_.addr_.s6_addr[i] < 0xFF)
+      {
+        ++address_.addr_.s6_addr[i];
+        break;
+      }
+
+      address_.addr_.s6_addr[i] = 0;
+    }
+
+    return *this;
+  }
+
+  /// Post-increment operator.
+  basic_address_iterator operator++(int) ASIO_NOEXCEPT
+  {
+    basic_address_iterator tmp(*this);
+    ++*this;
+    return tmp;
+  }
+
+  /// Pre-decrement operator.
+  basic_address_iterator& operator--() ASIO_NOEXCEPT
+  {
+    for (int i = 15; i >= 0; --i)
+    {
+      if (address_.addr_.s6_addr[i] > 0)
+      {
+        --address_.addr_.s6_addr[i];
+        break;
+      }
+
+      address_.addr_.s6_addr[i] = 0xFF;
+    }
+
+    return *this;
+  }
+
+  /// Post-decrement operator.
+  basic_address_iterator operator--(int)
+  {
+    basic_address_iterator tmp(*this);
+    --*this;
+    return tmp;
+  }
+
+  /// Compare two addresses for equality.
+  friend bool operator==(const basic_address_iterator& a,
+      const basic_address_iterator& b)
+  {
+    return a.address_ == b.address_;
+  }
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const basic_address_iterator& a,
+      const basic_address_iterator& b)
+  {
+    return a.address_ != b.address_;
+  }
+
+private:
+  address_v6 address_;
+};
+
+/// An input iterator that can be used for traversing IPv6 addresses.
+typedef basic_address_iterator<address_v6> address_v6_iterator;
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_ADDRESS_V6_ITERATOR_HPP
diff --git a/extern/include/asio/ip/address_v6_range.hpp b/extern/include/asio/ip/address_v6_range.hpp
new file mode 100644
index 00000000..9d7062ef
--- /dev/null
+++ b/extern/include/asio/ip/address_v6_range.hpp
@@ -0,0 +1,129 @@
+//
+// ip/address_v6_range.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//                         Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_ADDRESS_V6_RANGE_HPP
+#define ASIO_IP_ADDRESS_V6_RANGE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/ip/address_v6_iterator.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename> class basic_address_range;
+
+/// Represents a range of IPv6 addresses.
+/**
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <> class basic_address_range<address_v6>
+{
+public:
+  /// The type of an iterator that points into the range.
+  typedef basic_address_iterator<address_v6> iterator;
+
+  /// Construct an empty range.
+  basic_address_range() ASIO_NOEXCEPT
+    : begin_(address_v6()),
+      end_(address_v6())
+  {
+  }
+
+  /// Construct an range that represents the given range of addresses.
+  explicit basic_address_range(const iterator& first,
+      const iterator& last) ASIO_NOEXCEPT
+    : begin_(first),
+      end_(last)
+  {
+  }
+
+  /// Copy constructor.
+  basic_address_range(const basic_address_range& other) ASIO_NOEXCEPT
+    : begin_(other.begin_),
+      end_(other.end_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move constructor.
+  basic_address_range(basic_address_range&& other) ASIO_NOEXCEPT
+    : begin_(ASIO_MOVE_CAST(iterator)(other.begin_)),
+      end_(ASIO_MOVE_CAST(iterator)(other.end_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Assignment operator.
+  basic_address_range& operator=(
+      const basic_address_range& other) ASIO_NOEXCEPT
+  {
+    begin_ = other.begin_;
+    end_ = other.end_;
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move assignment operator.
+  basic_address_range& operator=(
+      basic_address_range&& other) ASIO_NOEXCEPT
+  {
+    begin_ = ASIO_MOVE_CAST(iterator)(other.begin_);
+    end_ = ASIO_MOVE_CAST(iterator)(other.end_);
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Obtain an iterator that points to the start of the range.
+  iterator begin() const ASIO_NOEXCEPT
+  {
+    return begin_;
+  }
+
+  /// Obtain an iterator that points to the end of the range.
+  iterator end() const ASIO_NOEXCEPT
+  {
+    return end_;
+  }
+
+  /// Determine whether the range is empty.
+  bool empty() const ASIO_NOEXCEPT
+  {
+    return begin_ == end_;
+  }
+
+  /// Find an address in the range.
+  iterator find(const address_v6& addr) const ASIO_NOEXCEPT
+  {
+    return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
+  }
+
+private:
+  iterator begin_;
+  iterator end_;
+};
+
+/// Represents a range of IPv6 addresses.
+typedef basic_address_range<address_v6> address_v6_range;
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_ADDRESS_V6_RANGE_HPP
diff --git a/extern/include/asio/ip/bad_address_cast.hpp b/extern/include/asio/ip/bad_address_cast.hpp
new file mode 100644
index 00000000..8c71f704
--- /dev/null
+++ b/extern/include/asio/ip/bad_address_cast.hpp
@@ -0,0 +1,48 @@
+//
+// ip/bad_address_cast.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_BAD_ADDRESS_CAST_HPP
+#define ASIO_IP_BAD_ADDRESS_CAST_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <typeinfo>
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+/// Thrown to indicate a failed address conversion.
+class bad_address_cast : public std::bad_cast
+{
+public:
+  /// Default constructor.
+  bad_address_cast() {}
+
+  /// Destructor.
+  virtual ~bad_address_cast() ASIO_NOEXCEPT_OR_NOTHROW {}
+
+  /// Get the message associated with the exception.
+  virtual const char* what() const ASIO_NOEXCEPT_OR_NOTHROW
+  {
+    return "bad address cast";
+  }
+};
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_ADDRESS_HPP
diff --git a/extern/include/asio/ip/basic_endpoint.hpp b/extern/include/asio/ip/basic_endpoint.hpp
index a1bae970..4418ee77 100644
--- a/extern/include/asio/ip/basic_endpoint.hpp
+++ b/extern/include/asio/ip/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // ip/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -97,13 +97,13 @@ class basic_endpoint
   {
   }
 
-#if defined(ASIO_HAS_MOVE)
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Move constructor.
   basic_endpoint(basic_endpoint&& other)
     : impl_(other.impl_)
   {
   }
-#endif // defined(ASIO_HAS_MOVE)
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Assign from another endpoint.
   basic_endpoint& operator=(const basic_endpoint& other)
@@ -112,14 +112,14 @@ class basic_endpoint
     return *this;
   }
 
-#if defined(ASIO_HAS_MOVE)
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Move-assign from another endpoint.
   basic_endpoint& operator=(basic_endpoint&& other)
   {
     impl_ = other.impl_;
     return *this;
   }
-#endif // defined(ASIO_HAS_MOVE)
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// The protocol associated with the endpoint.
   protocol_type protocol() const
diff --git a/extern/include/asio/ip/basic_resolver.hpp b/extern/include/asio/ip/basic_resolver.hpp
index 7e2f4285..812dbec5 100644
--- a/extern/include/asio/ip/basic_resolver.hpp
+++ b/extern/include/asio/ip/basic_resolver.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,13 +16,36 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include <string>
+#include "asio/async_result.hpp"
 #include "asio/basic_io_object.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/string_view.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
+#include "asio/io_context.hpp"
 #include "asio/ip/basic_resolver_iterator.hpp"
 #include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/resolver_service.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
+#include "asio/ip/resolver_base.hpp"
+
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/ip/resolver_service.hpp"
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+# if defined(ASIO_WINDOWS_RUNTIME)
+#  include "asio/detail/winrt_resolver_service.hpp"
+#  define ASIO_SVC_T \
+    asio::detail::winrt_resolver_service<InternetProtocol>
+# else
+#  include "asio/detail/resolver_service.hpp"
+#  define ASIO_SVC_T \
+    asio::detail::resolver_service<InternetProtocol>
+# endif
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 #include "asio/detail/push_options.hpp"
 
@@ -38,35 +61,130 @@ namespace ip {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
-template <typename InternetProtocol,
-    typename ResolverService = resolver_service<InternetProtocol> >
+template <typename InternetProtocol
+    ASIO_SVC_TPARAM_DEF1(= resolver_service<InternetProtocol>)>
 class basic_resolver
-  : public basic_io_object<ResolverService>
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>,
+    public resolver_base
 {
 public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
   /// The protocol type.
   typedef InternetProtocol protocol_type;
 
   /// The endpoint type.
   typedef typename InternetProtocol::endpoint endpoint_type;
 
-  /// The query type.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated.) The query type.
   typedef basic_resolver_query<InternetProtocol> query;
 
-  /// The iterator type.
+  /// (Deprecated.) The iterator type.
   typedef basic_resolver_iterator<InternetProtocol> iterator;
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// The results type.
+  typedef basic_resolver_results<InternetProtocol> results_type;
 
   /// Constructor.
   /**
    * This constructor creates a basic_resolver.
    *
-   * @param io_service The io_service object that the resolver will use to
-   * dispatch handlers for any asynchronous operations performed on the timer.
+   * @param io_context The io_context object that the resolver will use to
+   * dispatch handlers for any asynchronous operations performed on the
+   * resolver.
+   */
+  explicit basic_resolver(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_resolver from another.
+  /**
+   * This constructor moves a resolver from one object to another.
+   *
+   * @param other The other basic_resolver 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_resolver(io_context&) constructor.
+   */
+  basic_resolver(basic_resolver&& other)
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_resolver from another.
+  /**
+   * This assignment operator moves a resolver from one object to another.
+   * Cancels any outstanding asynchronous operations associated with the target
+   * object.
+   *
+   * @param other The other basic_resolver 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_resolver(io_context&) constructor.
+   */
+  basic_resolver& operator=(basic_resolver&& other)
+  {
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the resolver.
+  /**
+   * This function destroys the resolver, cancelling any outstanding
+   * asynchronous wait operations associated with the resolver as if by calling
+   * @c cancel.
+   */
+  ~basic_resolver()
+  {
+  }
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+  // These functions are provided by basic_io_object<>.
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
    */
-  explicit basic_resolver(asio::io_service& io_service)
-    : basic_io_object<ResolverService>(io_service)
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
   {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
   }
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
   /// Cancel any asynchronous operations that are waiting on the resolver.
   /**
@@ -76,56 +194,414 @@ class basic_resolver
    */
   void cancel()
   {
-    return this->service.cancel(this->implementation);
+    return this->get_service().cancel(this->get_implementation());
   }
 
-  /// Perform forward resolution of a query to a list of entries.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated.) Perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve a query into a list of endpoint entries.
    *
    * @param q A query object that determines what endpoints will be returned.
    *
-   * @returns A forward-only iterator that can be used to traverse the list
-   * of endpoint entries.
+   * @returns A range object representing the list of endpoint entries. A
+   * successful call to this function is guaranteed to return a non-empty
+   * range.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  results_type resolve(const query& q)
+  {
+    asio::error_code ec;
+    results_type r = this->get_service().resolve(
+        this->get_implementation(), q, ec);
+    asio::detail::throw_error(ec, "resolve");
+    return r;
+  }
+
+  /// (Deprecated.) Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve a query into a list of endpoint entries.
+   *
+   * @param q A query object that determines what endpoints will be returned.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns A range object representing the list of endpoint entries. An
+   * empty range is returned if an error occurs. A successful call to this
+   * function is guaranteed to return a non-empty range.
+   */
+  results_type resolve(const query& q, asio::error_code& ec)
+  {
+    return this->get_service().resolve(this->get_implementation(), q, ec);
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @returns A range object representing the list of endpoint entries. A
+   * successful call to this function is guaranteed to return a non-empty
+   * range.
    *
    * @throws asio::system_error Thrown on failure.
    *
-   * @note A default constructed iterator represents the end of the list.
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
    *
-   * A successful call to this function is guaranteed to return at least one
-   * entry.
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
    */
-  iterator resolve(const query& q)
+  results_type resolve(ASIO_STRING_VIEW_PARAM host,
+      ASIO_STRING_VIEW_PARAM service)
+  {
+    return resolve(host, service, resolver_base::flags());
+  }
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns A range object representing the list of endpoint entries. An
+   * empty range is returned if an error occurs. A successful call to this
+   * function is guaranteed to return a non-empty range.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  results_type resolve(ASIO_STRING_VIEW_PARAM host,
+      ASIO_STRING_VIEW_PARAM service, asio::error_code& ec)
+  {
+    return resolve(host, service, resolver_base::flags(), ec);
+  }
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
+   *
+   * @returns A range object representing the list of endpoint entries. A
+   * successful call to this function is guaranteed to return a non-empty
+   * range.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  results_type resolve(ASIO_STRING_VIEW_PARAM host,
+      ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags)
   {
     asio::error_code ec;
-    iterator i = this->service.resolve(this->implementation, q, ec);
+    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
+        static_cast<std::string>(service), resolve_flags);
+    results_type r = this->get_service().resolve(
+        this->get_implementation(), q, ec);
     asio::detail::throw_error(ec, "resolve");
-    return i;
+    return r;
   }
 
   /// Perform forward resolution of a query to a list of entries.
   /**
-   * This function is used to resolve a query into a list of endpoint entries.
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
    *
-   * @param q A query object that determines what endpoints will be returned.
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
-   * @returns A forward-only iterator that can be used to traverse the list
-   * of endpoint entries. Returns a default constructed iterator if an error
-   * occurs.
+   * @returns A range object representing the list of endpoint entries. An
+   * empty range is returned if an error occurs. A successful call to this
+   * function is guaranteed to return a non-empty range.
    *
-   * @note A default constructed iterator represents the end of the list.
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
    *
-   * A successful call to this function is guaranteed to return at least one
-   * entry.
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
    */
-  iterator resolve(const query& q, asio::error_code& ec)
+  results_type resolve(ASIO_STRING_VIEW_PARAM host,
+      ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags,
+      asio::error_code& ec)
   {
-    return this->service.resolve(this->implementation, q, ec);
+    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
+        static_cast<std::string>(service), resolve_flags);
+    return this->get_service().resolve(this->get_implementation(), q, ec);
   }
 
-  /// Asynchronously perform forward resolution of a query to a list of entries.
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @returns A range object representing the list of endpoint entries. A
+   * successful call to this function is guaranteed to return a non-empty
+   * range.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  results_type resolve(const protocol_type& protocol,
+      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service)
+  {
+    return resolve(protocol, host, service, resolver_base::flags());
+  }
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns A range object representing the list of endpoint entries. An
+   * empty range is returned if an error occurs. A successful call to this
+   * function is guaranteed to return a non-empty range.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  results_type resolve(const protocol_type& protocol,
+      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+      asio::error_code& ec)
+  {
+    return resolve(protocol, host, service, resolver_base::flags(), ec);
+  }
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
+   *
+   * @returns A range object representing the list of endpoint entries. A
+   * successful call to this function is guaranteed to return a non-empty
+   * range.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  results_type resolve(const protocol_type& protocol,
+      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+      resolver_base::flags resolve_flags)
+  {
+    asio::error_code ec;
+    basic_resolver_query<protocol_type> q(
+        protocol, static_cast<std::string>(host),
+        static_cast<std::string>(service), resolve_flags);
+    results_type r = this->get_service().resolve(
+        this->get_implementation(), q, ec);
+    asio::detail::throw_error(ec, "resolve");
+    return r;
+  }
+
+  /// Perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns A range object representing the list of endpoint entries. An
+   * empty range is returned if an error occurs. A successful call to this
+   * function is guaranteed to return a non-empty range.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  results_type resolve(const protocol_type& protocol,
+      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+      resolver_base::flags resolve_flags, asio::error_code& ec)
+  {
+    basic_resolver_query<protocol_type> q(
+        protocol, static_cast<std::string>(host),
+        static_cast<std::string>(service), resolve_flags);
+    return this->get_service().resolve(this->get_implementation(), q, ec);
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated.) Asynchronously perform forward resolution of a query to a
+  /// list of entries.
   /**
    * This function is used to asynchronously resolve a query into a list of
    * endpoint entries.
@@ -137,35 +613,307 @@ class basic_resolver
    * signature of the handler must be:
    * @code void handler(
    *   const asio::error_code& error, // Result of operation.
-   *   resolver::iterator iterator             // Forward-only iterator that can
-   *                                           // be used to traverse the list
-   *                                           // of endpoint entries.
+   *   resolver::results_type results // Resolved endpoints as a range.
    * ); @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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
-   * @note A default constructed iterator represents the end of the list.
-   *
-   * A successful resolve operation is guaranteed to pass at least one entry to
+   * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
    */
   template <typename ResolveHandler>
   ASIO_INITFN_RESULT_TYPE(ResolveHandler,
-      void (asio::error_code, iterator))
+      void (asio::error_code, results_type))
   async_resolve(const query& q,
       ASIO_MOVE_ARG(ResolveHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a ResolveHandler.
     ASIO_RESOLVE_HANDLER_CHECK(
-        ResolveHandler, handler, iterator) type_check;
+        ResolveHandler, handler, results_type) type_check;
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_resolve(this->get_implementation(), q,
+        ASIO_MOVE_CAST(ResolveHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    asio::async_completion<ResolveHandler,
+      void (asio::error_code, results_type)> init(handler);
+
+    this->get_service().async_resolve(
+        this->get_implementation(), q, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Asynchronously perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param handler The handler to be called when the resolve operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   resolver::results_type results // Resolved endpoints as a range.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * A successful resolve operation is guaranteed to pass a non-empty range to
+   * the handler.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  template <typename ResolveHandler>
+  ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (asio::error_code, results_type))
+  async_resolve(ASIO_STRING_VIEW_PARAM host,
+      ASIO_STRING_VIEW_PARAM service,
+      ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    return async_resolve(host, service, resolver_base::flags(),
+        ASIO_MOVE_CAST(ResolveHandler)(handler));
+  }
+
+  /// Asynchronously perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
+   *
+   * @param handler The handler to be called when the resolve operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   resolver::results_type results // Resolved endpoints as a range.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * A successful resolve operation is guaranteed to pass a non-empty range to
+   * the handler.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  template <typename ResolveHandler>
+  ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (asio::error_code, results_type))
+  async_resolve(ASIO_STRING_VIEW_PARAM host,
+      ASIO_STRING_VIEW_PARAM service,
+      resolver_base::flags resolve_flags,
+      ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ResolveHandler.
+    ASIO_RESOLVE_HANDLER_CHECK(
+        ResolveHandler, handler, results_type) type_check;
 
-    return this->service.async_resolve(this->implementation, q,
+    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
+        static_cast<std::string>(service), resolve_flags);
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_resolve(this->get_implementation(), q,
+        ASIO_MOVE_CAST(ResolveHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    asio::async_completion<ResolveHandler,
+      void (asio::error_code, results_type)> init(handler);
+
+    this->get_service().async_resolve(
+        this->get_implementation(), q, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+
+  /// Asynchronously perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param handler The handler to be called when the resolve operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   resolver::results_type results // Resolved endpoints as a range.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * A successful resolve operation is guaranteed to pass a non-empty range to
+   * the handler.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  template <typename ResolveHandler>
+  ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (asio::error_code, results_type))
+  async_resolve(const protocol_type& protocol,
+      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+      ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    return async_resolve(protocol, host, service, resolver_base::flags(),
         ASIO_MOVE_CAST(ResolveHandler)(handler));
   }
 
+  /// Asynchronously perform forward resolution of a query to a list of entries.
+  /**
+   * This function is used to resolve host and service names into a list of
+   * endpoint entries.
+   *
+   * @param protocol A protocol object, normally representing either the IPv4 or
+   * IPv6 version of an internet protocol.
+   *
+   * @param host A string identifying a location. May be a descriptive name or
+   * a numeric address string. If an empty string and the passive flag has been
+   * specified, the resolved endpoints are suitable for local service binding.
+   * If an empty string and passive is not specified, the resolved endpoints
+   * will use the loopback address.
+   *
+   * @param service A string identifying the requested service. This may be a
+   * descriptive name or a numeric string corresponding to a port number. May
+   * be an empty string, in which case all resolved endpoints will have a port
+   * number of 0.
+   *
+   * @param resolve_flags A set of flags that determine how name resolution
+   * should be performed. The default flags are suitable for communication with
+   * remote hosts.
+   *
+   * @param handler The handler to be called when the resolve operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   resolver::results_type results // Resolved endpoints as a range.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * A successful resolve operation is guaranteed to pass a non-empty range to
+   * the handler.
+   *
+   * @note On POSIX systems, host names may be locally defined in the file
+   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
+   * resolution is performed using DNS. Operating systems may use additional
+   * locations when resolving host names (such as NETBIOS names on Windows).
+   *
+   * On POSIX systems, service names are typically defined in the file
+   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
+   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
+   * may use additional locations when resolving service names.
+   */
+  template <typename ResolveHandler>
+  ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (asio::error_code, results_type))
+  async_resolve(const protocol_type& protocol,
+      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+      resolver_base::flags resolve_flags,
+      ASIO_MOVE_ARG(ResolveHandler) handler)
+  {
+    // If you get an error on the following line it means that your handler does
+    // not meet the documented type requirements for a ResolveHandler.
+    ASIO_RESOLVE_HANDLER_CHECK(
+        ResolveHandler, handler, results_type) type_check;
+
+    basic_resolver_query<protocol_type> q(
+        protocol, static_cast<std::string>(host),
+        static_cast<std::string>(service), resolve_flags);
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_resolve(this->get_implementation(), q,
+        ASIO_MOVE_CAST(ResolveHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    asio::async_completion<ResolveHandler,
+      void (asio::error_code, results_type)> init(handler);
+
+    this->get_service().async_resolve(
+        this->get_implementation(), q, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+  }
+
   /// Perform reverse resolution of an endpoint to a list of entries.
   /**
    * This function is used to resolve an endpoint into a list of endpoint
@@ -174,20 +922,17 @@ class basic_resolver
    * @param e An endpoint object that determines what endpoints will be
    * returned.
    *
-   * @returns A forward-only iterator that can be used to traverse the list
-   * of endpoint entries.
+   * @returns A range object representing the list of endpoint entries. A
+   * successful call to this function is guaranteed to return a non-empty
+   * range.
    *
    * @throws asio::system_error Thrown on failure.
-   *
-   * @note A default constructed iterator represents the end of the list.
-   *
-   * A successful call to this function is guaranteed to return at least one
-   * entry.
    */
-  iterator resolve(const endpoint_type& e)
+  results_type resolve(const endpoint_type& e)
   {
     asio::error_code ec;
-    iterator i = this->service.resolve(this->implementation, e, ec);
+    results_type i = this->get_service().resolve(
+        this->get_implementation(), e, ec);
     asio::detail::throw_error(ec, "resolve");
     return i;
   }
@@ -202,18 +947,13 @@ class basic_resolver
    *
    * @param ec Set to indicate what error occurred, if any.
    *
-   * @returns A forward-only iterator that can be used to traverse the list
-   * of endpoint entries. Returns a default constructed iterator if an error
-   * occurs.
-   *
-   * @note A default constructed iterator represents the end of the list.
-   *
-   * A successful call to this function is guaranteed to return at least one
-   * entry.
+   * @returns A range object representing the list of endpoint entries. An
+   * empty range is returned if an error occurs. A successful call to this
+   * function is guaranteed to return a non-empty range.
    */
-  iterator resolve(const endpoint_type& e, asio::error_code& ec)
+  results_type resolve(const endpoint_type& e, asio::error_code& ec)
   {
-    return this->service.resolve(this->implementation, e, ec);
+    return this->get_service().resolve(this->get_implementation(), e, ec);
   }
 
   /// Asynchronously perform reverse resolution of an endpoint to a list of
@@ -230,33 +970,39 @@ class basic_resolver
    * signature of the handler must be:
    * @code void handler(
    *   const asio::error_code& error, // Result of operation.
-   *   resolver::iterator iterator             // Forward-only iterator that can
-   *                                           // be used to traverse the list
-   *                                           // of endpoint entries.
+   *   resolver::results_type results // Resolved endpoints as a range.
    * ); @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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
-   * @note A default constructed iterator represents the end of the list.
-   *
-   * A successful resolve operation is guaranteed to pass at least one entry to
+   * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
    */
   template <typename ResolveHandler>
   ASIO_INITFN_RESULT_TYPE(ResolveHandler,
-      void (asio::error_code, iterator))
+      void (asio::error_code, results_type))
   async_resolve(const endpoint_type& e,
       ASIO_MOVE_ARG(ResolveHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a ResolveHandler.
     ASIO_RESOLVE_HANDLER_CHECK(
-        ResolveHandler, handler, iterator) type_check;
+        ResolveHandler, handler, results_type) type_check;
 
-    return this->service.async_resolve(this->implementation, e,
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+    return this->get_service().async_resolve(this->get_implementation(), e,
         ASIO_MOVE_CAST(ResolveHandler)(handler));
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+    asio::async_completion<ResolveHandler,
+      void (asio::error_code, results_type)> init(handler);
+
+    this->get_service().async_resolve(
+        this->get_implementation(), e, init.completion_handler);
+
+    return init.result.get();
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
   }
 };
 
@@ -265,4 +1011,8 @@ class basic_resolver
 
 #include "asio/detail/pop_options.hpp"
 
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# undef ASIO_SVC_T
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_IP_BASIC_RESOLVER_HPP
diff --git a/extern/include/asio/ip/basic_resolver_entry.hpp b/extern/include/asio/ip/basic_resolver_entry.hpp
index 8ad45a83..99bcbd29 100644
--- a/extern/include/asio/ip/basic_resolver_entry.hpp
+++ b/extern/include/asio/ip/basic_resolver_entry.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver_entry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include "asio/detail/config.hpp"
 #include <string>
+#include "asio/detail/string_view.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -49,10 +50,10 @@ class basic_resolver_entry
 
   /// Construct with specified endpoint, host name and service name.
   basic_resolver_entry(const endpoint_type& ep,
-      const std::string& host, const std::string& service)
+      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service)
     : endpoint_(ep),
-      host_name_(host),
-      service_name_(service)
+      host_name_(static_cast<std::string>(host)),
+      service_name_(static_cast<std::string>(service))
   {
   }
 
@@ -74,12 +75,30 @@ class basic_resolver_entry
     return host_name_;
   }
 
+  /// Get the host name associated with the entry.
+  template <class Allocator>
+  std::basic_string<char, std::char_traits<char>, Allocator> host_name(
+      const Allocator& alloc = Allocator()) const
+  {
+    return std::basic_string<char, std::char_traits<char>, Allocator>(
+        host_name_.c_str(), alloc);
+  }
+
   /// Get the service name associated with the entry.
   std::string service_name() const
   {
     return service_name_;
   }
 
+  /// Get the service name associated with the entry.
+  template <class Allocator>
+  std::basic_string<char, std::char_traits<char>, Allocator> service_name(
+      const Allocator& alloc = Allocator()) const
+  {
+    return std::basic_string<char, std::char_traits<char>, Allocator>(
+        service_name_.c_str(), alloc);
+  }
+
 private:
   endpoint_type endpoint_;
   std::string host_name_;
diff --git a/extern/include/asio/ip/basic_resolver_iterator.hpp b/extern/include/asio/ip/basic_resolver_iterator.hpp
index 09b1368b..ec5412cf 100644
--- a/extern/include/asio/ip/basic_resolver_iterator.hpp
+++ b/extern/include/asio/ip/basic_resolver_iterator.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,7 +21,7 @@
 #include <iterator>
 #include <string>
 #include <vector>
-#include "asio/detail/shared_ptr.hpp"
+#include "asio/detail/memory.hpp"
 #include "asio/detail/socket_ops.hpp"
 #include "asio/detail/socket_types.hpp"
 #include "asio/ip/basic_resolver_entry.hpp"
@@ -72,114 +72,45 @@ class basic_resolver_iterator
   {
   }
 
-  /// Create an iterator from an addrinfo list returned by getaddrinfo.
-  static basic_resolver_iterator create(
-      asio::detail::addrinfo_type* address_info,
-      const std::string& host_name, const std::string& service_name)
+  /// Copy constructor.
+  basic_resolver_iterator(const basic_resolver_iterator& other)
+    : values_(other.values_),
+      index_(other.index_)
   {
-    basic_resolver_iterator iter;
-    if (!address_info)
-      return iter;
-
-    std::string actual_host_name = host_name;
-    if (address_info->ai_canonname)
-      actual_host_name = address_info->ai_canonname;
-
-    iter.values_.reset(new values_type);
-
-    while (address_info)
-    {
-      if (address_info->ai_family == ASIO_OS_DEF(AF_INET)
-          || address_info->ai_family == ASIO_OS_DEF(AF_INET6))
-      {
-        using namespace std; // For memcpy.
-        typename InternetProtocol::endpoint endpoint;
-        endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
-        memcpy(endpoint.data(), address_info->ai_addr,
-            address_info->ai_addrlen);
-        iter.values_->push_back(
-            basic_resolver_entry<InternetProtocol>(endpoint,
-              actual_host_name, service_name));
-      }
-      address_info = address_info->ai_next;
-    }
-
-    return iter;
   }
 
-  /// Create an iterator from an endpoint, host name and service name.
-  static basic_resolver_iterator create(
-      const typename InternetProtocol::endpoint& endpoint,
-      const std::string& host_name, const std::string& service_name)
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  basic_resolver_iterator(basic_resolver_iterator&& other)
+    : values_(ASIO_MOVE_CAST(values_ptr_type)(other.values_)),
+      index_(other.index_)
   {
-    basic_resolver_iterator iter;
-    iter.values_.reset(new values_type);
-    iter.values_->push_back(
-        basic_resolver_entry<InternetProtocol>(
-          endpoint, host_name, service_name));
-    return iter;
+    other.index_ = 0;
   }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
-  /// Create an iterator from a sequence of endpoints, host and service name.
-  template <typename EndpointIterator>
-  static basic_resolver_iterator create(
-      EndpointIterator begin, EndpointIterator end,
-      const std::string& host_name, const std::string& service_name)
+  /// Assignment operator.
+  basic_resolver_iterator& operator=(const basic_resolver_iterator& other)
   {
-    basic_resolver_iterator iter;
-    if (begin != end)
-    {
-      iter.values_.reset(new values_type);
-      for (EndpointIterator ep_iter = begin; ep_iter != end; ++ep_iter)
-      {
-        iter.values_->push_back(
-            basic_resolver_entry<InternetProtocol>(
-              *ep_iter, host_name, service_name));
-      }
-    }
-    return iter;
+    values_ = other.values_;
+    index_ = other.index_;
+    return *this;
   }
 
-#if defined(ASIO_WINDOWS_RUNTIME)
-  /// Create an iterator from a Windows Runtime list of EndpointPair objects.
-  static basic_resolver_iterator create(
-      Windows::Foundation::Collections::IVectorView<
-        Windows::Networking::EndpointPair^>^ endpoints,
-      const asio::detail::addrinfo_type& hints,
-      const std::string& host_name, const std::string& service_name)
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-assignment operator.
+  basic_resolver_iterator& operator=(basic_resolver_iterator&& other)
   {
-    basic_resolver_iterator iter;
-    if (endpoints->Size)
+    if (this != &other)
     {
-      iter.values_.reset(new values_type);
-      for (unsigned int i = 0; i < endpoints->Size; ++i)
-      {
-        auto pair = endpoints->GetAt(i);
-
-        if (hints.ai_family == ASIO_OS_DEF(AF_INET)
-            && pair->RemoteHostName->Type
-              != Windows::Networking::HostNameType::Ipv4)
-          continue;
-
-        if (hints.ai_family == ASIO_OS_DEF(AF_INET6)
-            && pair->RemoteHostName->Type
-              != Windows::Networking::HostNameType::Ipv6)
-          continue;
-
-        iter.values_->push_back(
-            basic_resolver_entry<InternetProtocol>(
-              typename InternetProtocol::endpoint(
-                ip::address::from_string(
-                  asio::detail::winrt_utils::string(
-                    pair->RemoteHostName->CanonicalName)),
-                asio::detail::winrt_utils::integer(
-                  pair->RemoteServiceName)),
-              host_name, service_name));
-      }
+      values_ = ASIO_MOVE_CAST(values_ptr_type)(other.values_);
+      index_ = other.index_;
+      other.index_ = 0;
     }
-    return iter;
+
+    return *this;
   }
-#endif // defined(ASIO_WINDOWS_RUNTIME)
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Dereference an iterator.
   const basic_resolver_entry<InternetProtocol>& operator*() const
@@ -222,7 +153,7 @@ class basic_resolver_iterator
     return !a.equal(b);
   }
 
-private:
+protected:
   void increment()
   {
     if (++index_ == values_->size())
@@ -248,7 +179,8 @@ class basic_resolver_iterator
   }
 
   typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
-  asio::detail::shared_ptr<values_type> values_;
+  typedef asio::detail::shared_ptr<values_type> values_ptr_type;
+  values_ptr_type values_;
   std::size_t index_;
 };
 
diff --git a/extern/include/asio/ip/basic_resolver_query.hpp b/extern/include/asio/ip/basic_resolver_query.hpp
index ced5724a..84cd98d5 100644
--- a/extern/include/asio/ip/basic_resolver_query.hpp
+++ b/extern/include/asio/ip/basic_resolver_query.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver_query.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ip/basic_resolver_results.hpp b/extern/include/asio/ip/basic_resolver_results.hpp
new file mode 100644
index 00000000..185075f0
--- /dev/null
+++ b/extern/include/asio/ip/basic_resolver_results.hpp
@@ -0,0 +1,311 @@
+//
+// ip/basic_resolver_results.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_BASIC_RESOLVER_RESULTS_HPP
+#define ASIO_IP_BASIC_RESOLVER_RESULTS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <cstddef>
+#include <cstring>
+#include "asio/detail/socket_ops.hpp"
+#include "asio/detail/socket_types.hpp"
+#include "asio/ip/basic_resolver_iterator.hpp"
+
+#if defined(ASIO_WINDOWS_RUNTIME)
+# include "asio/detail/winrt_utils.hpp"
+#endif // defined(ASIO_WINDOWS_RUNTIME)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+/// A range of entries produced by a resolver.
+/**
+ * The asio::ip::basic_resolver_results class template is used to define
+ * a range over the results returned by a resolver.
+ *
+ * The iterator's value_type, obtained when a results iterator is dereferenced,
+ * is: @code const basic_resolver_entry<InternetProtocol> @endcode
+ *
+ * @note For backward compatibility, basic_resolver_results is derived from
+ * basic_resolver_iterator. This derivation is deprecated.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename InternetProtocol>
+class basic_resolver_results
+#if !defined(ASIO_NO_DEPRECATED)
+  : public basic_resolver_iterator<InternetProtocol>
+#else // !defined(ASIO_NO_DEPRECATED)
+  : private basic_resolver_iterator<InternetProtocol>
+#endif // !defined(ASIO_NO_DEPRECATED)
+{
+public:
+  /// The protocol type associated with the results.
+  typedef InternetProtocol protocol_type;
+
+  /// The endpoint type associated with the results.
+  typedef typename protocol_type::endpoint endpoint_type;
+
+  /// The type of a value in the results range.
+  typedef basic_resolver_entry<protocol_type> value_type;
+
+  /// The type of a const reference to a value in the range.
+  typedef const value_type& const_reference;
+
+  /// The type of a non-const reference to a value in the range.
+  typedef value_type& reference;
+
+  /// The type of an iterator into the range.
+  typedef basic_resolver_iterator<protocol_type> const_iterator;
+
+  /// The type of an iterator into the range.
+  typedef const_iterator iterator;
+
+  /// Type used to represent the distance between two iterators in the range.
+  typedef std::ptrdiff_t difference_type;
+
+  /// Type used to represent a count of the elements in the range.
+  typedef std::size_t size_type;
+
+  /// Default constructor creates an empty range.
+  basic_resolver_results()
+  {
+  }
+
+  /// Copy constructor.
+  basic_resolver_results(const basic_resolver_results& other)
+    : basic_resolver_iterator<InternetProtocol>(other)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  basic_resolver_results(basic_resolver_results&& other)
+    : basic_resolver_iterator<InternetProtocol>(
+        ASIO_MOVE_CAST(basic_resolver_results)(other))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Assignment operator.
+  basic_resolver_results& operator=(const basic_resolver_results& other)
+  {
+    basic_resolver_iterator<InternetProtocol>::operator=(other);
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-assignment operator.
+  basic_resolver_results& operator=(basic_resolver_results&& other)
+  {
+    basic_resolver_iterator<InternetProtocol>::operator=(
+        ASIO_MOVE_CAST(basic_resolver_results)(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(GENERATING_DOCUMENTATION)
+  // Create results from an addrinfo list returned by getaddrinfo.
+  static basic_resolver_results create(
+      asio::detail::addrinfo_type* address_info,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_results results;
+    if (!address_info)
+      return results;
+
+    std::string actual_host_name = host_name;
+    if (address_info->ai_canonname)
+      actual_host_name = address_info->ai_canonname;
+
+    results.values_.reset(new values_type);
+
+    while (address_info)
+    {
+      if (address_info->ai_family == ASIO_OS_DEF(AF_INET)
+          || address_info->ai_family == ASIO_OS_DEF(AF_INET6))
+      {
+        using namespace std; // For memcpy.
+        typename InternetProtocol::endpoint endpoint;
+        endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
+        memcpy(endpoint.data(), address_info->ai_addr,
+            address_info->ai_addrlen);
+        results.values_->push_back(
+            basic_resolver_entry<InternetProtocol>(endpoint,
+              actual_host_name, service_name));
+      }
+      address_info = address_info->ai_next;
+    }
+
+    return results;
+  }
+
+  // Create results from an endpoint, host name and service name.
+  static basic_resolver_results create(const endpoint_type& endpoint,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_results results;
+    results.values_.reset(new values_type);
+    results.values_->push_back(
+        basic_resolver_entry<InternetProtocol>(
+          endpoint, host_name, service_name));
+    return results;
+  }
+
+  // Create results from a sequence of endpoints, host and service name.
+  template <typename EndpointIterator>
+  static basic_resolver_results create(
+      EndpointIterator begin, EndpointIterator end,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_results results;
+    if (begin != end)
+    {
+      results.values_.reset(new values_type);
+      for (EndpointIterator ep_iter = begin; ep_iter != end; ++ep_iter)
+      {
+        results.values_->push_back(
+            basic_resolver_entry<InternetProtocol>(
+              *ep_iter, host_name, service_name));
+      }
+    }
+    return results;
+  }
+
+# if defined(ASIO_WINDOWS_RUNTIME)
+  // Create results from a Windows Runtime list of EndpointPair objects.
+  static basic_resolver_results create(
+      Windows::Foundation::Collections::IVectorView<
+        Windows::Networking::EndpointPair^>^ endpoints,
+      const asio::detail::addrinfo_type& hints,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_results results;
+    if (endpoints->Size)
+    {
+      results.values_.reset(new values_type);
+      for (unsigned int i = 0; i < endpoints->Size; ++i)
+      {
+        auto pair = endpoints->GetAt(i);
+
+        if (hints.ai_family == ASIO_OS_DEF(AF_INET)
+            && pair->RemoteHostName->Type
+              != Windows::Networking::HostNameType::Ipv4)
+          continue;
+
+        if (hints.ai_family == ASIO_OS_DEF(AF_INET6)
+            && pair->RemoteHostName->Type
+              != Windows::Networking::HostNameType::Ipv6)
+          continue;
+
+        results.values_->push_back(
+            basic_resolver_entry<InternetProtocol>(
+              typename InternetProtocol::endpoint(
+                ip::make_address(
+                  asio::detail::winrt_utils::string(
+                    pair->RemoteHostName->CanonicalName)),
+                asio::detail::winrt_utils::integer(
+                  pair->RemoteServiceName)),
+              host_name, service_name));
+      }
+    }
+    return results;
+  }
+# endif // defined(ASIO_WINDOWS_RUNTIME)
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  /// Get the number of entries in the results range.
+  size_type size() const ASIO_NOEXCEPT
+  {
+    return this->values_->size();
+  }
+
+  /// Get the maximum number of entries permitted in a results range.
+  size_type max_size() const ASIO_NOEXCEPT
+  {
+    return this->values_->max_size();
+  }
+
+  /// Determine whether the results range is empty.
+  bool empty() const ASIO_NOEXCEPT
+  {
+    return this->values_->empty();
+  }
+
+  /// Obtain a begin iterator for the results range.
+  const_iterator begin() const
+  {
+    basic_resolver_results tmp(*this);
+    tmp.index_ = 0;
+    return tmp;
+  }
+
+  /// Obtain an end iterator for the results range.
+  const_iterator end() const
+  {
+    return const_iterator();
+  }
+
+  /// Obtain a begin iterator for the results range.
+  const_iterator cbegin() const
+  {
+    return begin();
+  }
+
+  /// Obtain an end iterator for the results range.
+  const_iterator cend() const
+  {
+    return end();
+  }
+
+  /// Swap the results range with another.
+  void swap(basic_resolver_results& that) ASIO_NOEXCEPT
+  {
+    if (this != &that)
+    {
+      this->values_.swap(that.values_);
+      std::size_t index = this->index_;
+      this->index_ = that.index_;
+      that.index_ = index;
+    }
+  }
+
+  /// Test two iterators for equality.
+  friend bool operator==(const basic_resolver_results& a,
+      const basic_resolver_results& b)
+  {
+    return a.equal(b);
+  }
+
+  /// Test two iterators for inequality.
+  friend bool operator!=(const basic_resolver_results& a,
+      const basic_resolver_results& b)
+  {
+    return !a.equal(b);
+  }
+
+private:
+  typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
+};
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_BASIC_RESOLVER_RESULTS_HPP
diff --git a/extern/include/asio/ip/detail/endpoint.hpp b/extern/include/asio/ip/detail/endpoint.hpp
index 847ca4c0..9acefe5f 100644
--- a/extern/include/asio/ip/detail/endpoint.hpp
+++ b/extern/include/asio/ip/detail/endpoint.hpp
@@ -2,7 +2,7 @@
 // ip/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -113,7 +113,7 @@ class endpoint
 
 #if !defined(ASIO_NO_IOSTREAM)
   // Convert to a string.
-  ASIO_DECL std::string to_string(asio::error_code& ec) const;
+  ASIO_DECL std::string to_string() const;
 #endif // !defined(ASIO_NO_IOSTREAM)
 
 private:
diff --git a/extern/include/asio/ip/detail/impl/endpoint.ipp b/extern/include/asio/ip/detail/impl/endpoint.ipp
index 769277f1..304bdf3d 100644
--- a/extern/include/asio/ip/detail/impl/endpoint.ipp
+++ b/extern/include/asio/ip/detail/impl/endpoint.ipp
@@ -2,7 +2,7 @@
 // ip/detail/impl/endpoint.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -57,13 +57,13 @@ endpoint::endpoint(int family, unsigned short port_num)
       asio::detail::socket_ops::host_to_network_short(port_num);
     data_.v6.sin6_flowinfo = 0;
     data_.v6.sin6_addr.s6_addr[0] = 0; data_.v6.sin6_addr.s6_addr[1] = 0;
-    data_.v6.sin6_addr.s6_addr[2] = 0, data_.v6.sin6_addr.s6_addr[3] = 0;
-    data_.v6.sin6_addr.s6_addr[4] = 0, data_.v6.sin6_addr.s6_addr[5] = 0;
-    data_.v6.sin6_addr.s6_addr[6] = 0, data_.v6.sin6_addr.s6_addr[7] = 0;
-    data_.v6.sin6_addr.s6_addr[8] = 0, data_.v6.sin6_addr.s6_addr[9] = 0;
-    data_.v6.sin6_addr.s6_addr[10] = 0, data_.v6.sin6_addr.s6_addr[11] = 0;
-    data_.v6.sin6_addr.s6_addr[12] = 0, data_.v6.sin6_addr.s6_addr[13] = 0;
-    data_.v6.sin6_addr.s6_addr[14] = 0, data_.v6.sin6_addr.s6_addr[15] = 0;
+    data_.v6.sin6_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;
   }
 }
@@ -80,8 +80,7 @@ endpoint::endpoint(const asio::ip::address& addr,
       asio::detail::socket_ops::host_to_network_short(port_num);
     data_.v4.sin_addr.s_addr =
       asio::detail::socket_ops::host_to_network_long(
-          static_cast<asio::detail::u_long_type>(
-            addr.to_v4().to_ulong()));
+        addr.to_v4().to_uint());
   }
   else
   {
@@ -177,18 +176,14 @@ bool operator<(const endpoint& e1, const endpoint& e2)
 }
 
 #if !defined(ASIO_NO_IOSTREAM)
-std::string endpoint::to_string(asio::error_code& ec) const
+std::string endpoint::to_string() const
 {
-  std::string a = address().to_string(ec);
-  if (ec)
-    return std::string();
-
   std::ostringstream tmp_os;
   tmp_os.imbue(std::locale::classic());
   if (is_v4())
-    tmp_os << a;
+    tmp_os << address();
   else
-    tmp_os << '[' << a << ']';
+    tmp_os << '[' << address() << ']';
   tmp_os << ':' << port();
 
   return tmp_os.str();
diff --git a/extern/include/asio/ip/detail/socket_option.hpp b/extern/include/asio/ip/detail/socket_option.hpp
index cb029184..051ef30d 100644
--- a/extern/include/asio/ip/detail/socket_option.hpp
+++ b/extern/include/asio/ip/detail/socket_option.hpp
@@ -2,7 +2,7 @@
 // detail/socket_option.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -391,15 +391,15 @@ class multicast_request
   }
 
   // Construct with multicast address only.
-  explicit multicast_request(const asio::ip::address& multicast_address)
+  explicit multicast_request(const address& multicast_address)
     : ipv4_value_(), // Zero-initialisation gives the "any" address.
       ipv6_value_() // Zero-initialisation gives the "any" address.
   {
     if (multicast_address.is_v6())
     {
       using namespace std; // For memcpy.
-      asio::ip::address_v6 ipv6_address = multicast_address.to_v6();
-      asio::ip::address_v6::bytes_type bytes = ipv6_address.to_bytes();
+      address_v6 ipv6_address = multicast_address.to_v6();
+      address_v6::bytes_type bytes = ipv6_address.to_bytes();
       memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
       ipv6_value_.ipv6mr_interface = ipv6_address.scope_id();
     }
@@ -407,37 +407,34 @@ class multicast_request
     {
       ipv4_value_.imr_multiaddr.s_addr =
         asio::detail::socket_ops::host_to_network_long(
-            multicast_address.to_v4().to_ulong());
+            multicast_address.to_v4().to_uint());
       ipv4_value_.imr_interface.s_addr =
         asio::detail::socket_ops::host_to_network_long(
-            asio::ip::address_v4::any().to_ulong());
+            address_v4::any().to_uint());
     }
   }
 
   // Construct with multicast address and IPv4 address specifying an interface.
-  explicit multicast_request(
-      const asio::ip::address_v4& multicast_address,
-      const asio::ip::address_v4& network_interface
-        = asio::ip::address_v4::any())
+  explicit multicast_request(const address_v4& multicast_address,
+      const address_v4& network_interface = address_v4::any())
     : ipv6_value_() // Zero-initialisation gives the "any" address.
   {
     ipv4_value_.imr_multiaddr.s_addr =
       asio::detail::socket_ops::host_to_network_long(
-          multicast_address.to_ulong());
+          multicast_address.to_uint());
     ipv4_value_.imr_interface.s_addr =
       asio::detail::socket_ops::host_to_network_long(
-          network_interface.to_ulong());
+          network_interface.to_uint());
   }
 
   // Construct with multicast address and IPv6 network interface index.
   explicit multicast_request(
-      const asio::ip::address_v6& multicast_address,
+      const address_v6& multicast_address,
       unsigned long network_interface = 0)
     : ipv4_value_() // Zero-initialisation gives the "any" address.
   {
     using namespace std; // For memcpy.
-    asio::ip::address_v6::bytes_type bytes =
-      multicast_address.to_bytes();
+    address_v6::bytes_type bytes = multicast_address.to_bytes();
     memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
     if (network_interface)
       ipv6_value_.ipv6mr_interface = network_interface;
@@ -496,16 +493,16 @@ class network_interface
   {
     ipv4_value_.s_addr =
       asio::detail::socket_ops::host_to_network_long(
-          asio::ip::address_v4::any().to_ulong());
+          address_v4::any().to_uint());
     ipv6_value_ = 0;
   }
 
   // Construct with IPv4 interface.
-  explicit network_interface(const asio::ip::address_v4& ipv4_interface)
+  explicit network_interface(const address_v4& ipv4_interface)
   {
     ipv4_value_.s_addr =
       asio::detail::socket_ops::host_to_network_long(
-          ipv4_interface.to_ulong());
+          ipv4_interface.to_uint());
     ipv6_value_ = 0;
   }
 
@@ -514,7 +511,7 @@ class network_interface
   {
     ipv4_value_.s_addr =
       asio::detail::socket_ops::host_to_network_long(
-          asio::ip::address_v4::any().to_ulong());
+          address_v4::any().to_uint());
     ipv6_value_ = ipv6_interface;
   }
 
diff --git a/extern/include/asio/ip/host_name.hpp b/extern/include/asio/ip/host_name.hpp
index a5d6e592..d06de508 100644
--- a/extern/include/asio/ip/host_name.hpp
+++ b/extern/include/asio/ip/host_name.hpp
@@ -2,7 +2,7 @@
 // ip/host_name.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ip/icmp.hpp b/extern/include/asio/ip/icmp.hpp
index 26766e69..92e1953f 100644
--- a/extern/include/asio/ip/icmp.hpp
+++ b/extern/include/asio/ip/icmp.hpp
@@ -2,7 +2,7 @@
 // ip/icmp.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ip/impl/address.hpp b/extern/include/asio/ip/impl/address.hpp
index 5aea59ac..085b93f7 100644
--- a/extern/include/asio/ip/impl/address.hpp
+++ b/extern/include/asio/ip/impl/address.hpp
@@ -2,7 +2,7 @@
 // ip/impl/address.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -24,23 +24,37 @@
 namespace asio {
 namespace ip {
 
+#if !defined(ASIO_NO_DEPRECATED)
+
+inline address address::from_string(const char* str)
+{
+  return asio::ip::make_address(str);
+}
+
+inline address address::from_string(
+    const char* str, asio::error_code& ec)
+{
+  return asio::ip::make_address(str, ec);
+}
+
+inline address address::from_string(const std::string& str)
+{
+  return asio::ip::make_address(str);
+}
+
+inline address address::from_string(
+    const std::string& str, asio::error_code& ec)
+{
+  return asio::ip::make_address(str, ec);
+}
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address& addr)
 {
-  asio::error_code ec;
-  std::string s = addr.to_string(ec);
-  if (ec)
-  {
-    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
-      asio::detail::throw_error(ec);
-    else
-      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
-  }
-  else
-    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
-      os << os.widen(*i);
-  return os;
+  return os << addr.to_string().c_str();
 }
 
 } // namespace ip
diff --git a/extern/include/asio/ip/impl/address.ipp b/extern/include/asio/ip/impl/address.ipp
index 90f52af4..0523071f 100644
--- a/extern/include/asio/ip/impl/address.ipp
+++ b/extern/include/asio/ip/impl/address.ipp
@@ -2,7 +2,7 @@
 // ip/impl/address.ipp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,6 +21,7 @@
 #include "asio/detail/throw_exception.hpp"
 #include "asio/error.hpp"
 #include "asio/ip/address.hpp"
+#include "asio/ip/bad_address_cast.hpp"
 #include "asio/system_error.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -99,11 +100,60 @@ address& address::operator=(const asio::ip::address_v6& ipv6_address)
   return *this;
 }
 
+address make_address(const char* str)
+{
+  asio::error_code ec;
+  address addr = make_address(str, ec);
+  asio::detail::throw_error(ec);
+  return addr;
+}
+
+address make_address(const char* str, asio::error_code& ec)
+{
+  asio::ip::address_v6 ipv6_address =
+    asio::ip::make_address_v6(str, ec);
+  if (!ec)
+    return address(ipv6_address);
+
+  asio::ip::address_v4 ipv4_address =
+    asio::ip::make_address_v4(str, ec);
+  if (!ec)
+    return address(ipv4_address);
+
+  return address();
+}
+
+address make_address(const std::string& str)
+{
+  return make_address(str.c_str());
+}
+
+address make_address(const std::string& str,
+    asio::error_code& ec)
+{
+  return make_address(str.c_str(), ec);
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+address make_address(string_view str)
+{
+  return make_address(static_cast<std::string>(str));
+}
+
+address make_address(string_view str,
+    asio::error_code& ec)
+{
+  return make_address(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
 asio::ip::address_v4 address::to_v4() const
 {
   if (type_ != ipv4)
   {
-    std::bad_cast ex;
+    bad_address_cast ex;
     asio::detail::throw_exception(ex);
   }
   return ipv4_address_;
@@ -113,7 +163,7 @@ asio::ip::address_v6 address::to_v6() const
 {
   if (type_ != ipv6)
   {
-    std::bad_cast ex;
+    bad_address_cast ex;
     asio::detail::throw_exception(ex);
   }
   return ipv6_address_;
@@ -126,56 +176,14 @@ std::string address::to_string() const
   return ipv4_address_.to_string();
 }
 
+#if !defined(ASIO_NO_DEPRECATED)
 std::string address::to_string(asio::error_code& ec) const
 {
   if (type_ == ipv6)
     return ipv6_address_.to_string(ec);
   return ipv4_address_.to_string(ec);
 }
-
-address address::from_string(const char* str)
-{
-  asio::error_code ec;
-  address addr = from_string(str, ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-address address::from_string(const char* str, asio::error_code& ec)
-{
-  asio::ip::address_v6 ipv6_address =
-    asio::ip::address_v6::from_string(str, ec);
-  if (!ec)
-  {
-    address tmp;
-    tmp.type_ = ipv6;
-    tmp.ipv6_address_ = ipv6_address;
-    return tmp;
-  }
-
-  asio::ip::address_v4 ipv4_address =
-    asio::ip::address_v4::from_string(str, ec);
-  if (!ec)
-  {
-    address tmp;
-    tmp.type_ = ipv4;
-    tmp.ipv4_address_ = ipv4_address;
-    return tmp;
-  }
-
-  return address();
-}
-
-address address::from_string(const std::string& str)
-{
-  return from_string(str.c_str());
-}
-
-address address::from_string(const std::string& str,
-    asio::error_code& ec)
-{
-  return from_string(str.c_str(), ec);
-}
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 bool address::is_loopback() const
 {
diff --git a/extern/include/asio/ip/impl/address_v4.hpp b/extern/include/asio/ip/impl/address_v4.hpp
index 30e65dc5..d1cf407c 100644
--- a/extern/include/asio/ip/impl/address_v4.hpp
+++ b/extern/include/asio/ip/impl/address_v4.hpp
@@ -2,7 +2,7 @@
 // ip/impl/address_v4.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -24,23 +24,37 @@
 namespace asio {
 namespace ip {
 
+#if !defined(ASIO_NO_DEPRECATED)
+
+inline address_v4 address_v4::from_string(const char* str)
+{
+  return asio::ip::make_address_v4(str);
+}
+
+inline address_v4 address_v4::from_string(
+    const char* str, asio::error_code& ec)
+{
+  return asio::ip::make_address_v4(str, ec);
+}
+
+inline address_v4 address_v4::from_string(const std::string& str)
+{
+  return asio::ip::make_address_v4(str);
+}
+
+inline address_v4 address_v4::from_string(
+    const std::string& str, asio::error_code& ec)
+{
+  return asio::ip::make_address_v4(str, ec);
+}
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
 {
-  asio::error_code ec;
-  std::string s = addr.to_string(ec);
-  if (ec)
-  {
-    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
-      asio::detail::throw_error(ec);
-    else
-      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
-  }
-  else
-    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
-      os << os.widen(*i);
-  return os;
+  return os << addr.to_string().c_str();
 }
 
 } // namespace ip
diff --git a/extern/include/asio/ip/impl/address_v4.ipp b/extern/include/asio/ip/impl/address_v4.ipp
index 8193c6e0..9559addb 100644
--- a/extern/include/asio/ip/impl/address_v4.ipp
+++ b/extern/include/asio/ip/impl/address_v4.ipp
@@ -2,7 +2,7 @@
 // ip/impl/address_v4.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include "asio/detail/config.hpp"
 #include <climits>
+#include <limits>
 #include <stdexcept>
 #include "asio/error.hpp"
 #include "asio/detail/socket_ops.hpp"
@@ -44,15 +45,13 @@ address_v4::address_v4(const address_v4::bytes_type& bytes)
   memcpy(&addr_.s_addr, bytes.data(), 4);
 }
 
-address_v4::address_v4(unsigned long addr)
+address_v4::address_v4(address_v4::uint_type addr)
 {
-#if ULONG_MAX > 0xFFFFFFFF
-  if (addr > 0xFFFFFFFF)
+  if ((std::numeric_limits<uint_type>::max)() > 0xFFFFFFFF)
   {
-    std::out_of_range ex("address_v4 from unsigned long");
+    std::out_of_range ex("address_v4 from unsigned integer");
     asio::detail::throw_exception(ex);
   }
-#endif // ULONG_MAX > 0xFFFFFFFF
 
   addr_.s_addr = asio::detail::socket_ops::host_to_network_long(
       static_cast<asio::detail::u_long_type>(addr));
@@ -70,19 +69,32 @@ address_v4::bytes_type address_v4::to_bytes() const
   return bytes;
 }
 
+address_v4::uint_type address_v4::to_uint() const
+{
+  return asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
+}
+
+#if !defined(ASIO_NO_DEPRECATED)
 unsigned long address_v4::to_ulong() const
 {
   return asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 std::string address_v4::to_string() const
 {
   asio::error_code ec;
-  std::string addr = to_string(ec);
-  asio::detail::throw_error(ec);
+  char addr_str[asio::detail::max_addr_v4_str_len];
+  const char* addr =
+    asio::detail::socket_ops::inet_ntop(
+        ASIO_OS_DEF(AF_INET), &addr_, addr_str,
+        asio::detail::max_addr_v4_str_len, 0, ec);
+  if (addr == 0)
+    asio::detail::throw_error(ec);
   return addr;
 }
 
+#if !defined(ASIO_NO_DEPRECATED)
 std::string address_v4::to_string(asio::error_code& ec) const
 {
   char addr_str[asio::detail::max_addr_v4_str_len];
@@ -94,69 +106,44 @@ std::string address_v4::to_string(asio::error_code& ec) const
     return std::string();
   return addr;
 }
-
-address_v4 address_v4::from_string(const char* str)
-{
-  asio::error_code ec;
-  address_v4 addr = from_string(str, ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-address_v4 address_v4::from_string(
-    const char* str, asio::error_code& ec)
-{
-  address_v4 tmp;
-  if (asio::detail::socket_ops::inet_pton(
-        ASIO_OS_DEF(AF_INET), str, &tmp.addr_, 0, ec) <= 0)
-    return address_v4();
-  return tmp;
-}
-
-address_v4 address_v4::from_string(const std::string& str)
-{
-  return from_string(str.c_str());
-}
-
-address_v4 address_v4::from_string(
-    const std::string& str, asio::error_code& ec)
-{
-  return from_string(str.c_str(), ec);
-}
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 bool address_v4::is_loopback() const
 {
-  return (to_ulong() & 0xFF000000) == 0x7F000000;
+  return (to_uint() & 0xFF000000) == 0x7F000000;
 }
 
 bool address_v4::is_unspecified() const
 {
-  return to_ulong() == 0;
+  return to_uint() == 0;
 }
 
+#if !defined(ASIO_NO_DEPRECATED)
 bool address_v4::is_class_a() const
 {
-  return (to_ulong() & 0x80000000) == 0;
+  return (to_uint() & 0x80000000) == 0;
 }
 
 bool address_v4::is_class_b() const
 {
-  return (to_ulong() & 0xC0000000) == 0x80000000;
+  return (to_uint() & 0xC0000000) == 0x80000000;
 }
 
 bool address_v4::is_class_c() const
 {
-  return (to_ulong() & 0xE0000000) == 0xC0000000;
+  return (to_uint() & 0xE0000000) == 0xC0000000;
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 bool address_v4::is_multicast() const
 {
-  return (to_ulong() & 0xF0000000) == 0xE0000000;
+  return (to_uint() & 0xF0000000) == 0xE0000000;
 }
 
+#if !defined(ASIO_NO_DEPRECATED)
 address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
 {
-  return address_v4(addr.to_ulong() | (mask.to_ulong() ^ 0xFFFFFFFF));
+  return address_v4(addr.to_uint() | (mask.to_uint() ^ 0xFFFFFFFF));
 }
 
 address_v4 address_v4::netmask(const address_v4& addr)
@@ -169,6 +156,51 @@ address_v4 address_v4::netmask(const address_v4& addr)
     return address_v4(0xFFFFFF00);
   return address_v4(0xFFFFFFFF);
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+address_v4 make_address_v4(const char* str)
+{
+  asio::error_code ec;
+  address_v4 addr = make_address_v4(str, ec);
+  asio::detail::throw_error(ec);
+  return addr;
+}
+
+address_v4 make_address_v4(
+    const char* str, asio::error_code& ec)
+{
+  address_v4::bytes_type bytes;
+  if (asio::detail::socket_ops::inet_pton(
+        ASIO_OS_DEF(AF_INET), str, &bytes, 0, ec) <= 0)
+    return address_v4();
+  return address_v4(bytes);
+}
+
+address_v4 make_address_v4(const std::string& str)
+{
+  return make_address_v4(str.c_str());
+}
+
+address_v4 make_address_v4(
+    const std::string& str, asio::error_code& ec)
+{
+  return make_address_v4(str.c_str(), ec);
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+address_v4 make_address_v4(string_view str)
+{
+  return make_address_v4(static_cast<std::string>(str));
+}
+
+address_v4 make_address_v4(string_view str,
+    asio::error_code& ec)
+{
+  return make_address_v4(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
 
 } // namespace ip
 } // namespace asio
diff --git a/extern/include/asio/ip/impl/address_v6.hpp b/extern/include/asio/ip/impl/address_v6.hpp
index 326de7a6..330eafd1 100644
--- a/extern/include/asio/ip/impl/address_v6.hpp
+++ b/extern/include/asio/ip/impl/address_v6.hpp
@@ -2,7 +2,7 @@
 // ip/impl/address_v6.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -24,23 +24,37 @@
 namespace asio {
 namespace ip {
 
+#if !defined(ASIO_NO_DEPRECATED)
+
+inline address_v6 address_v6::from_string(const char* str)
+{
+  return asio::ip::make_address_v6(str);
+}
+
+inline address_v6 address_v6::from_string(
+    const char* str, asio::error_code& ec)
+{
+  return asio::ip::make_address_v6(str, ec);
+}
+
+inline address_v6 address_v6::from_string(const std::string& str)
+{
+  return asio::ip::make_address_v6(str);
+}
+
+inline address_v6 address_v6::from_string(
+    const std::string& str, asio::error_code& ec)
+{
+  return asio::ip::make_address_v6(str, ec);
+}
+
+#endif // !defined(ASIO_NO_DEPRECATED)
+
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
 {
-  asio::error_code ec;
-  std::string s = addr.to_string(ec);
-  if (ec)
-  {
-    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
-      asio::detail::throw_error(ec);
-    else
-      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
-  }
-  else
-    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
-      os << os.widen(*i);
-  return os;
+  return os << addr.to_string().c_str();
 }
 
 } // namespace ip
diff --git a/extern/include/asio/ip/impl/address_v6.ipp b/extern/include/asio/ip/impl/address_v6.ipp
index bf4103b7..36bd68cf 100644
--- a/extern/include/asio/ip/impl/address_v6.ipp
+++ b/extern/include/asio/ip/impl/address_v6.ipp
@@ -2,7 +2,7 @@
 // ip/impl/address_v6.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -24,6 +24,7 @@
 #include "asio/detail/throw_exception.hpp"
 #include "asio/error.hpp"
 #include "asio/ip/address_v6.hpp"
+#include "asio/ip/bad_address_cast.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -100,11 +101,17 @@ address_v6::bytes_type address_v6::to_bytes() const
 std::string address_v6::to_string() const
 {
   asio::error_code ec;
-  std::string addr = to_string(ec);
-  asio::detail::throw_error(ec);
+  char addr_str[asio::detail::max_addr_v6_str_len];
+  const char* addr =
+    asio::detail::socket_ops::inet_ntop(
+        ASIO_OS_DEF(AF_INET6), &addr_, addr_str,
+        asio::detail::max_addr_v6_str_len, scope_id_, ec);
+  if (addr == 0)
+    asio::detail::throw_error(ec);
   return addr;
 }
 
+#if !defined(ASIO_NO_DEPRECATED)
 std::string address_v6::to_string(asio::error_code& ec) const
 {
   char addr_str[asio::detail::max_addr_v6_str_len];
@@ -117,40 +124,11 @@ std::string address_v6::to_string(asio::error_code& ec) const
   return addr;
 }
 
-address_v6 address_v6::from_string(const char* str)
-{
-  asio::error_code ec;
-  address_v6 addr = from_string(str, ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-address_v6 address_v6::from_string(
-    const char* str, asio::error_code& ec)
-{
-  address_v6 tmp;
-  if (asio::detail::socket_ops::inet_pton(
-        ASIO_OS_DEF(AF_INET6), str, &tmp.addr_, &tmp.scope_id_, ec) <= 0)
-    return address_v6();
-  return tmp;
-}
-
-address_v6 address_v6::from_string(const std::string& str)
-{
-  return from_string(str.c_str());
-}
-
-address_v6 address_v6::from_string(
-    const std::string& str, asio::error_code& ec)
-{
-  return from_string(str.c_str(), ec);
-}
-
 address_v4 address_v6::to_v4() const
 {
   if (!is_v4_mapped() && !is_v4_compatible())
   {
-    std::bad_cast ex;
+    bad_address_cast ex;
     asio::detail::throw_exception(ex);
   }
 
@@ -158,6 +136,7 @@ address_v4 address_v6::to_v4() const
     addr_.s6_addr[13], addr_.s6_addr[14], addr_.s6_addr[15] } };
   return address_v4(v4_bytes);
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 bool address_v6::is_loopback() const
 {
@@ -203,6 +182,7 @@ bool address_v6::is_v4_mapped() const
       && (addr_.s6_addr[10] == 0xff) && (addr_.s6_addr[11] == 0xff));
 }
 
+#if !defined(ASIO_NO_DEPRECATED)
 bool address_v6::is_v4_compatible() const
 {
   return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
@@ -216,6 +196,7 @@ bool address_v6::is_v4_compatible() const
         && (addr_.s6_addr[14] == 0)
         && ((addr_.s6_addr[15] == 0) || (addr_.s6_addr[15] == 1))));
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 bool address_v6::is_multicast() const
 {
@@ -274,6 +255,7 @@ address_v6 address_v6::loopback()
   return tmp;
 }
 
+#if !defined(ASIO_NO_DEPRECATED)
 address_v6 address_v6::v4_mapped(const address_v4& addr)
 {
   address_v4::bytes_type v4_bytes = addr.to_bytes();
@@ -289,6 +271,76 @@ address_v6 address_v6::v4_compatible(const address_v4& addr)
     v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
   return address_v6(v6_bytes);
 }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+address_v6 make_address_v6(const char* str)
+{
+  asio::error_code ec;
+  address_v6 addr = make_address_v6(str, ec);
+  asio::detail::throw_error(ec);
+  return addr;
+}
+
+address_v6 make_address_v6(
+    const char* str, asio::error_code& ec)
+{
+  address_v6::bytes_type bytes;
+  unsigned long scope_id = 0;
+  if (asio::detail::socket_ops::inet_pton(
+        ASIO_OS_DEF(AF_INET6), str, &bytes[0], &scope_id, ec) <= 0)
+    return address_v6();
+  return address_v6(bytes, scope_id);
+}
+
+address_v6 make_address_v6(const std::string& str)
+{
+  return make_address_v6(str.c_str());
+}
+
+address_v6 make_address_v6(
+    const std::string& str, asio::error_code& ec)
+{
+  return make_address_v6(str.c_str(), ec);
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+address_v6 make_address_v6(string_view str)
+{
+  return make_address_v6(static_cast<std::string>(str));
+}
+
+address_v6 make_address_v6(string_view str,
+    asio::error_code& ec)
+{
+  return make_address_v6(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+address_v4 make_address_v4(
+    v4_mapped_t, const address_v6& v6_addr)
+{
+  if (!v6_addr.is_v4_mapped())
+  {
+    bad_address_cast ex;
+    asio::detail::throw_exception(ex);
+  }
+
+  address_v6::bytes_type v6_bytes = v6_addr.to_bytes();
+  address_v4::bytes_type v4_bytes = { { v6_bytes[12],
+    v6_bytes[13], v6_bytes[14], v6_bytes[15] } };
+  return address_v4(v4_bytes);
+}
+
+address_v6 make_address_v6(
+    v4_mapped_t, const address_v4& v4_addr)
+{
+  address_v4::bytes_type v4_bytes = v4_addr.to_bytes();
+  address_v6::bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0xFF, 0xFF, v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
+  return address_v6(v6_bytes);
+}
 
 } // namespace ip
 } // namespace asio
diff --git a/extern/include/asio/ip/impl/basic_endpoint.hpp b/extern/include/asio/ip/impl/basic_endpoint.hpp
index 2f15c4fa..5680a438 100644
--- a/extern/include/asio/ip/impl/basic_endpoint.hpp
+++ b/extern/include/asio/ip/impl/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // ip/impl/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -30,19 +30,7 @@ std::basic_ostream<Elem, Traits>& operator<<(
     const basic_endpoint<InternetProtocol>& endpoint)
 {
   asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
-  asio::error_code ec;
-  std::string s = tmp_ep.to_string(ec);
-  if (ec)
-  {
-    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
-      asio::detail::throw_error(ec);
-    else
-      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
-  }
-  else
-    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
-      os << os.widen(*i);
-  return os;
+  return os << tmp_ep.to_string().c_str();
 }
 
 } // namespace ip
diff --git a/extern/include/asio/ip/impl/host_name.ipp b/extern/include/asio/ip/impl/host_name.ipp
index b1dc38e8..932ab1c6 100644
--- a/extern/include/asio/ip/impl/host_name.ipp
+++ b/extern/include/asio/ip/impl/host_name.ipp
@@ -2,7 +2,7 @@
 // ip/impl/host_name.ipp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ip/impl/network_v4.hpp b/extern/include/asio/ip/impl/network_v4.hpp
new file mode 100644
index 00000000..911a45c3
--- /dev/null
+++ b/extern/include/asio/ip/impl/network_v4.hpp
@@ -0,0 +1,54 @@
+//
+// ip/impl/network_v4.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V4_HPP
+#define ASIO_IP_IMPL_NETWORK_V4_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const network_v4& addr)
+{
+  asio::error_code ec;
+  std::string s = addr.to_string(ec);
+  if (ec)
+  {
+    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+      asio::detail::throw_error(ec);
+    else
+      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
+  }
+  else
+    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
+      os << os.widen(*i);
+  return os;
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_NETWORK_V4_HPP
diff --git a/extern/include/asio/ip/impl/network_v4.ipp b/extern/include/asio/ip/impl/network_v4.ipp
new file mode 100644
index 00000000..4b278871
--- /dev/null
+++ b/extern/include/asio/ip/impl/network_v4.ipp
@@ -0,0 +1,216 @@
+//
+// ip/impl/network_v4.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V4_IPP
+#define ASIO_IP_IMPL_NETWORK_V4_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <stdexcept>
+#include "asio/error.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/ip/network_v4.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+network_v4::network_v4(const address_v4& addr, unsigned short prefix_len)
+  : address_(addr),
+    prefix_length_(prefix_len)
+{
+  if (prefix_len > 32)
+  {
+    std::out_of_range ex("prefix length too large");
+    asio::detail::throw_exception(ex);
+  }
+}
+
+network_v4::network_v4(const address_v4& addr, const address_v4& mask)
+  : address_(addr),
+    prefix_length_(0)
+{
+  address_v4::bytes_type mask_bytes = mask.to_bytes();
+  bool finished = false;
+  for (std::size_t i = 0; i < mask_bytes.size(); ++i)
+  {
+    if (finished)
+    {
+      if (mask_bytes[i])
+      {
+        std::invalid_argument ex("non-contiguous netmask");
+        asio::detail::throw_exception(ex);
+      }
+      continue;
+    }
+    else
+    {
+      switch (mask_bytes[i])
+      {
+      case 255:
+        prefix_length_ += 8;
+        break;
+      case 254: // prefix_length_ += 7
+        prefix_length_ += 1;
+      case 252: // prefix_length_ += 6
+        prefix_length_ += 1;
+      case 248: // prefix_length_ += 5
+        prefix_length_ += 1;
+      case 240: // prefix_length_ += 4
+        prefix_length_ += 1;
+      case 224: // prefix_length_ += 3
+        prefix_length_ += 1;
+      case 192: // prefix_length_ += 2
+        prefix_length_ += 1;
+      case 128: // prefix_length_ += 1
+        prefix_length_ += 1;
+      case 0:   // nbits += 0
+        finished = true;
+        break;
+      default:
+        std::out_of_range ex("non-contiguous netmask");
+        asio::detail::throw_exception(ex);
+      }
+    }
+  }
+}
+
+address_v4 network_v4::netmask() const ASIO_NOEXCEPT
+{
+  uint32_t nmbits = 0xffffffff;
+  if (prefix_length_ == 0)
+    nmbits = 0;
+  else
+    nmbits = nmbits << (32 - prefix_length_);
+  return address_v4(nmbits);
+}
+
+address_v4_range network_v4::hosts() const ASIO_NOEXCEPT
+{
+  return is_host()
+    ? address_v4_range(address_, address_v4(address_.to_uint() + 1))
+    : address_v4_range(address_v4(network().to_uint() + 1), broadcast());
+}
+
+bool network_v4::is_subnet_of(const network_v4& other) const
+{
+  if (other.prefix_length_ >= prefix_length_)
+    return false; // Only real subsets are allowed.
+  const network_v4 me(address_, other.prefix_length_);
+  return other.canonical() == me.canonical();
+}
+
+std::string network_v4::to_string() const
+{
+  asio::error_code ec;
+  std::string addr = to_string(ec);
+  asio::detail::throw_error(ec);
+  return addr;
+}
+
+std::string network_v4::to_string(asio::error_code& ec) const
+{
+  using namespace std; // For sprintf.
+  ec = asio::error_code();
+  char prefix_len[16];
+#if defined(ASIO_HAS_SECURE_RTL)
+  sprintf_s(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
+#else // defined(ASIO_HAS_SECURE_RTL)
+  sprintf(prefix_len, "/%u", prefix_length_);
+#endif // defined(ASIO_HAS_SECURE_RTL)
+  return address_.to_string() + prefix_len;
+}
+
+network_v4 make_network_v4(const char* str)
+{
+  return make_network_v4(std::string(str));
+}
+
+network_v4 make_network_v4(const char* str, asio::error_code& ec)
+{
+  return make_network_v4(std::string(str), ec);
+}
+
+network_v4 make_network_v4(const std::string& str)
+{
+  asio::error_code ec;
+  network_v4 net = make_network_v4(str, ec);
+  asio::detail::throw_error(ec);
+  return net;
+}
+
+network_v4 make_network_v4(const std::string& str,
+    asio::error_code& ec)
+{
+  std::string::size_type pos = str.find_first_of("/");
+
+  if (pos == std::string::npos)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v4();
+  }
+
+  if (pos == str.size() - 1)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v4();
+  }
+
+  std::string::size_type end = str.find_first_not_of("0123456789", pos + 1);
+  if (end != std::string::npos)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v4();
+  }
+
+  const address_v4 addr = make_address_v4(str.substr(0, pos), ec);
+  if (ec)
+    return network_v4();
+
+  const int prefix_len = std::atoi(str.substr(pos + 1).c_str());
+  if (prefix_len < 0 || prefix_len > 32)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v4();
+  }
+
+  return network_v4(addr, static_cast<unsigned short>(prefix_len));
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+network_v4 make_network_v4(string_view str)
+{
+  return make_network_v4(static_cast<std::string>(str));
+}
+
+network_v4 make_network_v4(string_view str,
+    asio::error_code& ec)
+{
+  return make_network_v4(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_NETWORK_V4_IPP
diff --git a/extern/include/asio/ip/impl/network_v6.hpp b/extern/include/asio/ip/impl/network_v6.hpp
new file mode 100644
index 00000000..b0eedade
--- /dev/null
+++ b/extern/include/asio/ip/impl/network_v6.hpp
@@ -0,0 +1,53 @@
+//
+// ip/impl/network_v6.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V6_HPP
+#define ASIO_IP_IMPL_NETWORK_V6_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+#include "asio/detail/throw_error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const network_v6& addr)
+{
+  asio::error_code ec;
+  std::string s = addr.to_string(ec);
+  if (ec)
+  {
+    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
+      asio::detail::throw_error(ec);
+    else
+      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
+  }
+  else
+    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
+      os << os.widen(*i);
+  return os;
+}
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+#endif // ASIO_IP_IMPL_NETWORK_V6_HPP
diff --git a/extern/include/asio/ip/impl/network_v6.ipp b/extern/include/asio/ip/impl/network_v6.ipp
new file mode 100644
index 00000000..2e37a99a
--- /dev/null
+++ b/extern/include/asio/ip/impl/network_v6.ipp
@@ -0,0 +1,185 @@
+//
+// ip/impl/network_v6.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_IMPL_NETWORK_V6_IPP
+#define ASIO_IP_IMPL_NETWORK_V6_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <stdexcept>
+#include "asio/error.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/ip/network_v6.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+network_v6::network_v6(const address_v6& addr, unsigned short prefix_len)
+  : address_(addr),
+    prefix_length_(prefix_len)
+{
+  if (prefix_len > 128)
+  {
+    std::out_of_range ex("prefix length too large");
+    asio::detail::throw_exception(ex);
+  }
+}
+
+ASIO_DECL address_v6 network_v6::network() const ASIO_NOEXCEPT
+{
+  address_v6::bytes_type bytes(address_.to_bytes());
+  for (std::size_t i = 0; i < 16; ++i)
+  {
+    if (prefix_length_ <= i * 8)
+      bytes[i] = 0;
+    else if (prefix_length_ < (i + 1) * 8)
+      bytes[i] &= 0xFF00 >> (prefix_length_ % 8);
+  }
+  return address_v6(bytes, address_.scope_id());
+}
+
+address_v6_range network_v6::hosts() const ASIO_NOEXCEPT
+{
+  address_v6::bytes_type begin_bytes(address_.to_bytes());
+  address_v6::bytes_type end_bytes(address_.to_bytes());
+  for (std::size_t i = 0; i < 16; ++i)
+  {
+    if (prefix_length_ <= i * 8)
+    {
+      begin_bytes[i] = 0;
+      end_bytes[i] = 0xFF;
+    }
+    else if (prefix_length_ < (i + 1) * 8)
+    {
+      begin_bytes[i] &= 0xFF00 >> (prefix_length_ % 8);
+      end_bytes[i] |= 0xFF >> (prefix_length_ % 8);
+    }
+  }
+  return address_v6_range(
+      address_v6_iterator(address_v6(begin_bytes, address_.scope_id())),
+      ++address_v6_iterator(address_v6(end_bytes, address_.scope_id())));
+}
+
+bool network_v6::is_subnet_of(const network_v6& other) const
+{
+  if (other.prefix_length_ >= prefix_length_)
+    return false; // Only real subsets are allowed.
+  const network_v6 me(address_, other.prefix_length_);
+  return other.canonical() == me.canonical();
+}
+
+std::string network_v6::to_string() const
+{
+  asio::error_code ec;
+  std::string addr = to_string(ec);
+  asio::detail::throw_error(ec);
+  return addr;
+}
+
+std::string network_v6::to_string(asio::error_code& ec) const
+{
+  using namespace std; // For sprintf.
+  ec = asio::error_code();
+  char prefix_len[16];
+#if defined(ASIO_HAS_SECURE_RTL)
+  sprintf_s(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
+#else // defined(ASIO_HAS_SECURE_RTL)
+  sprintf(prefix_len, "/%u", prefix_length_);
+#endif // defined(ASIO_HAS_SECURE_RTL)
+  return address_.to_string() + prefix_len;
+}
+
+network_v6 make_network_v6(const char* str)
+{
+  return make_network_v6(std::string(str));
+}
+
+network_v6 make_network_v6(const char* str, asio::error_code& ec)
+{
+  return make_network_v6(std::string(str), ec);
+}
+
+network_v6 make_network_v6(const std::string& str)
+{
+  asio::error_code ec;
+  network_v6 net = make_network_v6(str, ec);
+  asio::detail::throw_error(ec);
+  return net;
+}
+
+network_v6 make_network_v6(const std::string& str,
+    asio::error_code& ec)
+{
+  std::string::size_type pos = str.find_first_of("/");
+
+  if (pos == std::string::npos)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v6();
+  }
+
+  if (pos == str.size() - 1)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v6();
+  }
+
+  std::string::size_type end = str.find_first_not_of("0123456789", pos + 1);
+  if (end != std::string::npos)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v6();
+  }
+
+  const address_v6 addr = make_address_v6(str.substr(0, pos), ec);
+  if (ec)
+    return network_v6();
+
+  const int prefix_len = std::atoi(str.substr(pos + 1).c_str());
+  if (prefix_len < 0 || prefix_len > 128)
+  {
+    ec = asio::error::invalid_argument;
+    return network_v6();
+  }
+
+  return network_v6(addr, static_cast<unsigned short>(prefix_len));
+}
+
+#if defined(ASIO_HAS_STRING_VIEW)
+
+network_v6 make_network_v6(string_view str)
+{
+  return make_network_v6(static_cast<std::string>(str));
+}
+
+network_v6 make_network_v6(string_view str,
+    asio::error_code& ec)
+{
+  return make_network_v6(static_cast<std::string>(str), ec);
+}
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_IMPL_NETWORK_V6_IPP
diff --git a/extern/include/asio/ip/multicast.hpp b/extern/include/asio/ip/multicast.hpp
index 4af2c3a1..ea624e14 100644
--- a/extern/include/asio/ip/multicast.hpp
+++ b/extern/include/asio/ip/multicast.hpp
@@ -2,7 +2,7 @@
 // ip/multicast.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -32,7 +32,7 @@ namespace multicast {
  * @par Examples
  * Setting the option to join a multicast group:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::address multicast_address =
  *   asio::ip::address::from_string("225.0.0.1");
@@ -60,7 +60,7 @@ typedef asio::ip::detail::socket_option::multicast_request<
  * @par Examples
  * Setting the option to leave a multicast group:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::address multicast_address =
  *   asio::ip::address::from_string("225.0.0.1");
@@ -88,7 +88,7 @@ typedef asio::ip::detail::socket_option::multicast_request<
  * @par Examples
  * Setting the option:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::address_v4 local_interface =
  *   asio::ip::address_v4::from_string("1.2.3.4");
@@ -116,7 +116,7 @@ typedef asio::ip::detail::socket_option::network_interface<
  * @par Examples
  * Setting the option:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::multicast::hops option(4);
  * socket.set_option(option);
@@ -125,7 +125,7 @@ typedef asio::ip::detail::socket_option::network_interface<
  * @par
  * Getting the current option value:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::multicast::hops option;
  * socket.get_option(option);
@@ -153,7 +153,7 @@ typedef asio::ip::detail::socket_option::multicast_hops<
  * @par Examples
  * Setting the option:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::multicast::enable_loopback option(true);
  * socket.set_option(option);
@@ -162,7 +162,7 @@ typedef asio::ip::detail::socket_option::multicast_hops<
  * @par
  * Getting the current option value:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::multicast::enable_loopback option;
  * socket.get_option(option);
diff --git a/extern/include/asio/ip/network_v4.hpp b/extern/include/asio/ip/network_v4.hpp
new file mode 100644
index 00000000..e38f60fe
--- /dev/null
+++ b/extern/include/asio/ip/network_v4.hpp
@@ -0,0 +1,261 @@
+//
+// ip/network_v4.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_NETWORK_V4_HPP
+#define ASIO_IP_NETWORK_V4_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <string>
+#include "asio/detail/string_view.hpp"
+#include "asio/error_code.hpp"
+#include "asio/ip/address_v4_range.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+/// Represents an IPv4 network.
+/**
+ * The asio::ip::network_v4 class provides the ability to use and
+ * manipulate IP version 4 networks.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class network_v4
+{
+public:
+  /// Default constructor.
+  network_v4() ASIO_NOEXCEPT
+    : address_(),
+      prefix_length_(0)
+  {
+  }
+
+  /// Construct a network based on the specified address and prefix length.
+  ASIO_DECL network_v4(const address_v4& addr,
+      unsigned short prefix_len);
+
+  /// Construct network based on the specified address and netmask.
+  ASIO_DECL network_v4(const address_v4& addr,
+      const address_v4& mask);
+
+  /// Copy constructor.
+  network_v4(const network_v4& other) ASIO_NOEXCEPT
+    : address_(other.address_),
+      prefix_length_(other.prefix_length_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move constructor.
+  network_v4(network_v4&& other) ASIO_NOEXCEPT
+    : address_(ASIO_MOVE_CAST(address_v4)(other.address_)),
+      prefix_length_(other.prefix_length_)
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Assign from another network.
+  network_v4& operator=(const network_v4& other) ASIO_NOEXCEPT
+  {
+    address_ = other.address_;
+    prefix_length_ = other.prefix_length_;
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move-assign from another network.
+  network_v4& operator=(network_v4&& other) ASIO_NOEXCEPT
+  {
+    address_ = ASIO_MOVE_CAST(address_v4)(other.address_);
+    prefix_length_ = other.prefix_length_;
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Obtain the address object specified when the network object was created.
+  address_v4 address() const ASIO_NOEXCEPT
+  {
+    return address_;
+  }
+
+  /// Obtain the prefix length that was specified when the network object was
+  /// created.
+  unsigned short prefix_length() const ASIO_NOEXCEPT
+  {
+    return prefix_length_;
+  }
+
+  /// Obtain the netmask that was specified when the network object was created.
+  ASIO_DECL address_v4 netmask() const ASIO_NOEXCEPT;
+
+  /// Obtain an address object that represents the network address.
+  address_v4 network() const ASIO_NOEXCEPT
+  {
+    return address_v4(address_.to_uint() & netmask().to_uint());
+  }
+
+  /// Obtain an address object that represents the network's broadcast address.
+  address_v4 broadcast() const ASIO_NOEXCEPT
+  {
+    return address_v4(network().to_uint() | (netmask().to_uint() ^ 0xFFFFFFFF));
+  }
+
+  /// Obtain an address range corresponding to the hosts in the network.
+  ASIO_DECL address_v4_range hosts() const ASIO_NOEXCEPT;
+
+  /// Obtain the true network address, omitting any host bits.
+  network_v4 canonical() const ASIO_NOEXCEPT
+  {
+    return network_v4(network(), netmask());
+  }
+
+  /// Test if network is a valid host address.
+  bool is_host() const ASIO_NOEXCEPT
+  {
+    return prefix_length_ == 32;
+  }
+
+  /// Test if a network is a real subnet of another network.
+  ASIO_DECL bool is_subnet_of(const network_v4& other) const;
+
+  /// Get the network as an address in dotted decimal format.
+  ASIO_DECL std::string to_string() const;
+
+  /// Get the network as an address in dotted decimal format.
+  ASIO_DECL std::string to_string(asio::error_code& ec) const;
+
+  /// Compare two networks for equality.
+  friend bool operator==(const network_v4& a, const network_v4& b)
+  {
+    return a.address_ == b.address_ && a.prefix_length_ == b.prefix_length_;
+  }
+
+  /// Compare two networks for inequality.
+  friend bool operator!=(const network_v4& a, const network_v4& b)
+  {
+    return !(a == b);
+  }
+
+private:
+  address_v4 address_;
+  unsigned short prefix_length_;
+};
+
+/// Create an IPv4 network from an address and prefix length.
+/**
+ * @relates address_v4
+ */
+inline network_v4 make_network_v4(
+    const address_v4& addr, unsigned short prefix_len)
+{
+  return network_v4(addr, prefix_len);
+}
+
+/// Create an IPv4 network from an address and netmask.
+/**
+ * @relates address_v4
+ */
+inline network_v4 make_network_v4(
+    const address_v4& addr, const address_v4& mask)
+{
+  return network_v4(addr, mask);
+}
+
+/// Create an IPv4 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v4
+ */
+ASIO_DECL network_v4 make_network_v4(const char* str);
+
+/// Create an IPv4 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v4
+ */
+ASIO_DECL network_v4 make_network_v4(
+    const char* str, asio::error_code& ec);
+
+/// Create an IPv4 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v4
+ */
+ASIO_DECL network_v4 make_network_v4(const std::string& str);
+
+/// Create an IPv4 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v4
+ */
+ASIO_DECL network_v4 make_network_v4(
+    const std::string& str, asio::error_code& ec);
+
+#if defined(ASIO_HAS_STRING_VIEW) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Create an IPv4 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v4
+ */
+ASIO_DECL network_v4 make_network_v4(string_view str);
+
+/// Create an IPv4 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v4
+ */
+ASIO_DECL network_v4 make_network_v4(
+    string_view str, asio::error_code& ec);
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+       //  || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+/// Output a network as a string.
+/**
+ * Used to output a human-readable string for a specified network.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param net The network to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates asio::ip::address_v4
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const network_v4& net);
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/ip/impl/network_v4.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/ip/impl/network_v4.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_IP_NETWORK_V4_HPP
diff --git a/extern/include/asio/ip/network_v6.hpp b/extern/include/asio/ip/network_v6.hpp
new file mode 100644
index 00000000..7b6b7e61
--- /dev/null
+++ b/extern/include/asio/ip/network_v6.hpp
@@ -0,0 +1,235 @@
+//
+// ip/network_v6.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_NETWORK_V6_HPP
+#define ASIO_IP_NETWORK_V6_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <string>
+#include "asio/detail/string_view.hpp"
+#include "asio/error_code.hpp"
+#include "asio/ip/address_v6_range.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+/// Represents an IPv6 network.
+/**
+ * The asio::ip::network_v6 class provides the ability to use and
+ * manipulate IP version 6 networks.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class network_v6
+{
+public:
+  /// Default constructor.
+  network_v6() ASIO_NOEXCEPT
+    : address_(),
+      prefix_length_(0)
+  {
+  }
+
+  /// Construct a network based on the specified address and prefix length.
+  ASIO_DECL network_v6(const address_v6& addr,
+      unsigned short prefix_len);
+
+  /// Copy constructor.
+  network_v6(const network_v6& other) ASIO_NOEXCEPT
+    : address_(other.address_),
+      prefix_length_(other.prefix_length_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move constructor.
+  network_v6(network_v6&& other) ASIO_NOEXCEPT
+    : address_(ASIO_MOVE_CAST(address_v6)(other.address_)),
+      prefix_length_(other.prefix_length_)
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Assign from another network.
+  network_v6& operator=(const network_v6& other) ASIO_NOEXCEPT
+  {
+    address_ = other.address_;
+    prefix_length_ = other.prefix_length_;
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Move-assign from another network.
+  network_v6& operator=(network_v6&& other) ASIO_NOEXCEPT
+  {
+    address_ = ASIO_MOVE_CAST(address_v6)(other.address_);
+    prefix_length_ = other.prefix_length_;
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  /// Obtain the address object specified when the network object was created.
+  address_v6 address() const ASIO_NOEXCEPT
+  {
+    return address_;
+  }
+
+  /// Obtain the prefix length that was specified when the network object was
+  /// created.
+  unsigned short prefix_length() const ASIO_NOEXCEPT
+  {
+    return prefix_length_;
+  }
+
+  /// Obtain an address object that represents the network address.
+  ASIO_DECL address_v6 network() const ASIO_NOEXCEPT;
+
+  /// Obtain an address range corresponding to the hosts in the network.
+  ASIO_DECL address_v6_range hosts() const ASIO_NOEXCEPT;
+
+  /// Obtain the true network address, omitting any host bits.
+  network_v6 canonical() const ASIO_NOEXCEPT
+  {
+    return network_v6(network(), prefix_length());
+  }
+
+  /// Test if network is a valid host address.
+  bool is_host() const ASIO_NOEXCEPT
+  {
+    return prefix_length_ == 128;
+  }
+
+  /// Test if a network is a real subnet of another network.
+  ASIO_DECL bool is_subnet_of(const network_v6& other) const;
+
+  /// Get the network as an address in dotted decimal format.
+  ASIO_DECL std::string to_string() const;
+
+  /// Get the network as an address in dotted decimal format.
+  ASIO_DECL std::string to_string(asio::error_code& ec) const;
+
+  /// Compare two networks for equality.
+  friend bool operator==(const network_v6& a, const network_v6& b)
+  {
+    return a.address_ == b.address_ && a.prefix_length_ == b.prefix_length_;
+  }
+
+  /// Compare two networks for inequality.
+  friend bool operator!=(const network_v6& a, const network_v6& b)
+  {
+    return !(a == b);
+  }
+
+private:
+  address_v6 address_;
+  unsigned short prefix_length_;
+};
+
+/// Create an IPv6 network from an address and prefix length.
+/**
+ * @relates address_v6
+ */
+inline network_v6 make_network_v6(
+    const address_v6& addr, unsigned short prefix_len)
+{
+  return network_v6(addr, prefix_len);
+}
+
+/// Create an IPv6 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v6
+ */
+ASIO_DECL network_v6 make_network_v6(const char* str);
+
+/// Create an IPv6 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v6
+ */
+ASIO_DECL network_v6 make_network_v6(
+    const char* str, asio::error_code& ec);
+
+/// Create an IPv6 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v6
+ */
+ASIO_DECL network_v6 make_network_v6(const std::string& str);
+
+/// Create an IPv6 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v6
+ */
+ASIO_DECL network_v6 make_network_v6(
+    const std::string& str, asio::error_code& ec);
+
+#if defined(ASIO_HAS_STRING_VIEW) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Create an IPv6 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v6
+ */
+ASIO_DECL network_v6 make_network_v6(string_view str);
+
+/// Create an IPv6 network from a string containing IP address and prefix
+/// length.
+/**
+ * @relates network_v6
+ */
+ASIO_DECL network_v6 make_network_v6(
+    string_view str, asio::error_code& ec);
+
+#endif // defined(ASIO_HAS_STRING_VIEW)
+       //  || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+/// Output a network as a string.
+/**
+ * Used to output a human-readable string for a specified network.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param net The network to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates asio::ip::address_v6
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const network_v6& net);
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/ip/impl/network_v6.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/ip/impl/network_v6.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_IP_NETWORK_V6_HPP
diff --git a/extern/include/asio/ip/resolver_base.hpp b/extern/include/asio/ip/resolver_base.hpp
new file mode 100644
index 00000000..d32c9110
--- /dev/null
+++ b/extern/include/asio/ip/resolver_base.hpp
@@ -0,0 +1,129 @@
+//
+// ip/resolver_base.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IP_RESOLVER_BASE_HPP
+#define ASIO_IP_RESOLVER_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/socket_types.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+/// The resolver_base class is used as a base for the basic_resolver class
+/// templates to provide a common place to define the flag constants.
+class resolver_base
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// A bitmask type (C++ Std [lib.bitmask.types]).
+  typedef unspecified flags;
+
+  /// Determine the canonical name of the host specified in the query.
+  static const flags canonical_name = implementation_defined;
+
+  /// Indicate that returned endpoint is intended for use as a locally bound
+  /// socket endpoint.
+  static const flags passive = implementation_defined;
+
+  /// Host name should be treated as a numeric string defining an IPv4 or IPv6
+  /// address and no name resolution should be attempted.
+  static const flags numeric_host = implementation_defined;
+
+  /// Service name should be treated as a numeric string defining a port number
+  /// and no name resolution should be attempted.
+  static const flags numeric_service = implementation_defined;
+
+  /// If the query protocol family is specified as IPv6, return IPv4-mapped
+  /// IPv6 addresses on finding no IPv6 addresses.
+  static const flags v4_mapped = implementation_defined;
+
+  /// If used with v4_mapped, return all matching IPv6 and IPv4 addresses.
+  static const flags all_matching = implementation_defined;
+
+  /// Only return IPv4 addresses if a non-loopback IPv4 address is configured
+  /// for the system. Only return IPv6 addresses if a non-loopback IPv6 address
+  /// is configured for the system.
+  static const flags address_configured = implementation_defined;
+#else
+  enum flags
+  {
+    canonical_name = ASIO_OS_DEF(AI_CANONNAME),
+    passive = ASIO_OS_DEF(AI_PASSIVE),
+    numeric_host = ASIO_OS_DEF(AI_NUMERICHOST),
+    numeric_service = ASIO_OS_DEF(AI_NUMERICSERV),
+    v4_mapped = ASIO_OS_DEF(AI_V4MAPPED),
+    all_matching = ASIO_OS_DEF(AI_ALL),
+    address_configured = ASIO_OS_DEF(AI_ADDRCONFIG)
+  };
+
+  // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
+
+  friend flags operator&(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
+  }
+
+  friend flags operator|(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
+  }
+
+  friend flags operator^(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
+  }
+
+  friend flags operator~(flags x)
+  {
+    return static_cast<flags>(~static_cast<unsigned int>(x));
+  }
+
+  friend flags& operator&=(flags& x, flags y)
+  {
+    x = x & y;
+    return x;
+  }
+
+  friend flags& operator|=(flags& x, flags y)
+  {
+    x = x | y;
+    return x;
+  }
+
+  friend flags& operator^=(flags& x, flags y)
+  {
+    x = x ^ y;
+    return x;
+  }
+#endif
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~resolver_base()
+  {
+  }
+};
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_RESOLVER_BASE_HPP
diff --git a/extern/include/asio/ip/resolver_query_base.hpp b/extern/include/asio/ip/resolver_query_base.hpp
index bd1bde58..be368589 100644
--- a/extern/include/asio/ip/resolver_query_base.hpp
+++ b/extern/include/asio/ip/resolver_query_base.hpp
@@ -2,7 +2,7 @@
 // ip/resolver_query_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/detail/socket_types.hpp"
+#include "asio/ip/resolver_base.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -26,95 +26,8 @@ namespace ip {
 /// The resolver_query_base class is used as a base for the
 /// basic_resolver_query class templates to provide a common place to define
 /// the flag constants.
-class resolver_query_base
+class resolver_query_base : public resolver_base
 {
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// A bitmask type (C++ Std [lib.bitmask.types]).
-  typedef unspecified flags;
-
-  /// Determine the canonical name of the host specified in the query.
-  static const flags canonical_name = implementation_defined;
-
-  /// Indicate that returned endpoint is intended for use as a locally bound
-  /// socket endpoint.
-  static const flags passive = implementation_defined;
-
-  /// Host name should be treated as a numeric string defining an IPv4 or IPv6
-  /// address and no name resolution should be attempted.
-  static const flags numeric_host = implementation_defined;
-
-  /// Service name should be treated as a numeric string defining a port number
-  /// and no name resolution should be attempted.
-  static const flags numeric_service = implementation_defined;
-
-  /// If the query protocol family is specified as IPv6, return IPv4-mapped
-  /// IPv6 addresses on finding no IPv6 addresses.
-  static const flags v4_mapped = implementation_defined;
-
-  /// If used with v4_mapped, return all matching IPv6 and IPv4 addresses.
-  static const flags all_matching = implementation_defined;
-
-  /// Only return IPv4 addresses if a non-loopback IPv4 address is configured
-  /// for the system. Only return IPv6 addresses if a non-loopback IPv6 address
-  /// is configured for the system.
-  static const flags address_configured = implementation_defined;
-#else
-  enum flags
-  {
-    canonical_name = ASIO_OS_DEF(AI_CANONNAME),
-    passive = ASIO_OS_DEF(AI_PASSIVE),
-    numeric_host = ASIO_OS_DEF(AI_NUMERICHOST),
-    numeric_service = ASIO_OS_DEF(AI_NUMERICSERV),
-    v4_mapped = ASIO_OS_DEF(AI_V4MAPPED),
-    all_matching = ASIO_OS_DEF(AI_ALL),
-    address_configured = ASIO_OS_DEF(AI_ADDRCONFIG)
-  };
-
-  // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
-
-  friend flags operator&(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
-  }
-
-  friend flags operator|(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
-  }
-
-  friend flags operator^(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
-  }
-
-  friend flags operator~(flags x)
-  {
-    return static_cast<flags>(~static_cast<unsigned int>(x));
-  }
-
-  friend flags& operator&=(flags& x, flags y)
-  {
-    x = x & y;
-    return x;
-  }
-
-  friend flags& operator|=(flags& x, flags y)
-  {
-    x = x | y;
-    return x;
-  }
-
-  friend flags& operator^=(flags& x, flags y)
-  {
-    x = x ^ y;
-    return x;
-  }
-#endif
-
 protected:
   /// Protected destructor to prevent deletion through this type.
   ~resolver_query_base()
diff --git a/extern/include/asio/ip/resolver_service.hpp b/extern/include/asio/ip/resolver_service.hpp
index 7f0b6aa4..519d72db 100644
--- a/extern/include/asio/ip/resolver_service.hpp
+++ b/extern/include/asio/ip/resolver_service.hpp
@@ -2,7 +2,7 @@
 // ip/resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,15 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/async_result.hpp"
 #include "asio/error_code.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/ip/basic_resolver_iterator.hpp"
 #include "asio/ip/basic_resolver_query.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/winrt_resolver_service.hpp"
@@ -37,7 +41,7 @@ namespace ip {
 template <typename InternetProtocol>
 class resolver_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<
       resolver_service<InternetProtocol> >
@@ -46,7 +50,7 @@ class resolver_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The protocol type.
@@ -61,6 +65,9 @@ class resolver_service
   /// The iterator type.
   typedef basic_resolver_iterator<InternetProtocol> iterator_type;
 
+  /// The results type.
+  typedef basic_resolver_results<InternetProtocol> results_type;
+
 private:
   // The type of the platform-specific implementation.
 #if defined(ASIO_WINDOWS_RUNTIME)
@@ -79,11 +86,11 @@ class resolver_service
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// Construct a new resolver service for the specified io_service.
-  explicit resolver_service(asio::io_service& io_service)
+  /// Construct a new resolver service for the specified io_context.
+  explicit resolver_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        resolver_service<InternetProtocol> >(io_service),
-      service_impl_(io_service)
+        resolver_service<InternetProtocol> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -93,6 +100,23 @@ class resolver_service
     service_impl_.construct(impl);
   }
 
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new resolver implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another resolver implementation.
+  void move_assign(implementation_type& impl,
+      resolver_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Destroy a resolver implementation.
   void destroy(implementation_type& impl)
   {
@@ -106,7 +130,7 @@ class resolver_service
   }
 
   /// Resolve a query to a list of entries.
-  iterator_type resolve(implementation_type& impl, const query_type& query,
+  results_type resolve(implementation_type& impl, const query_type& query,
       asio::error_code& ec)
   {
     return service_impl_.resolve(impl, query, ec);
@@ -115,21 +139,20 @@ class resolver_service
   /// Asynchronously resolve a query to a list of entries.
   template <typename ResolveHandler>
   ASIO_INITFN_RESULT_TYPE(ResolveHandler,
-      void (asio::error_code, iterator_type))
+      void (asio::error_code, results_type))
   async_resolve(implementation_type& impl, const query_type& query,
       ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    asio::detail::async_result_init<
-      ResolveHandler, void (asio::error_code, iterator_type)> init(
-        ASIO_MOVE_CAST(ResolveHandler)(handler));
+    asio::async_completion<ResolveHandler,
+      void (asio::error_code, results_type)> init(handler);
 
-    service_impl_.async_resolve(impl, query, init.handler);
+    service_impl_.async_resolve(impl, query, init.completion_handler);
 
     return init.result.get();
   }
 
   /// Resolve an endpoint to a list of entries.
-  iterator_type resolve(implementation_type& impl,
+  results_type resolve(implementation_type& impl,
       const endpoint_type& endpoint, asio::error_code& ec)
   {
     return service_impl_.resolve(impl, endpoint, ec);
@@ -138,30 +161,29 @@ class resolver_service
   /// Asynchronously resolve an endpoint to a list of entries.
   template <typename ResolveHandler>
   ASIO_INITFN_RESULT_TYPE(ResolveHandler,
-      void (asio::error_code, iterator_type))
+      void (asio::error_code, results_type))
   async_resolve(implementation_type& impl, const endpoint_type& endpoint,
       ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    asio::detail::async_result_init<
-      ResolveHandler, void (asio::error_code, iterator_type)> init(
-        ASIO_MOVE_CAST(ResolveHandler)(handler));
+    asio::async_completion<ResolveHandler,
+      void (asio::error_code, results_type)> init(handler);
 
-    service_impl_.async_resolve(impl, endpoint, init.handler);
+    service_impl_.async_resolve(impl, endpoint, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // Perform any fork-related housekeeping.
-  void fork_service(asio::io_service::fork_event event)
+  void notify_fork(asio::io_context::fork_event event)
   {
-    service_impl_.fork_service(event);
+    service_impl_.notify_fork(event);
   }
 
   // The platform-specific implementation.
@@ -173,4 +195,6 @@ class resolver_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_IP_RESOLVER_SERVICE_HPP
diff --git a/extern/include/asio/ip/tcp.hpp b/extern/include/asio/ip/tcp.hpp
index 90009f4e..f1adeb02 100644
--- a/extern/include/asio/ip/tcp.hpp
+++ b/extern/include/asio/ip/tcp.hpp
@@ -2,7 +2,7 @@
 // ip/tcp.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -99,7 +99,7 @@ class tcp
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::ip::tcp::no_delay option(true);
    * socket.set_option(option);
@@ -108,7 +108,7 @@ class tcp
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::ip::tcp::no_delay option;
    * socket.get_option(option);
diff --git a/extern/include/asio/ip/udp.hpp b/extern/include/asio/ip/udp.hpp
index 35c3f95e..1c93f9b0 100644
--- a/extern/include/asio/ip/udp.hpp
+++ b/extern/include/asio/ip/udp.hpp
@@ -2,7 +2,7 @@
 // ip/udp.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ip/unicast.hpp b/extern/include/asio/ip/unicast.hpp
index b07d10bf..14e3e489 100644
--- a/extern/include/asio/ip/unicast.hpp
+++ b/extern/include/asio/ip/unicast.hpp
@@ -2,7 +2,7 @@
 // ip/unicast.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -32,7 +32,7 @@ namespace unicast {
  * @par Examples
  * Setting the option:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::unicast::hops option(4);
  * socket.set_option(option);
@@ -41,7 +41,7 @@ namespace unicast {
  * @par
  * Getting the current option value:
  * @code
- * asio::ip::udp::socket socket(io_service); 
+ * asio::ip::udp::socket socket(io_context); 
  * ...
  * asio::ip::unicast::hops option;
  * socket.get_option(option);
diff --git a/extern/include/asio/ip/v6_only.hpp b/extern/include/asio/ip/v6_only.hpp
index 9b51097c..ac7234ed 100644
--- a/extern/include/asio/ip/v6_only.hpp
+++ b/extern/include/asio/ip/v6_only.hpp
@@ -2,7 +2,7 @@
 // ip/v6_only.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,7 +31,7 @@ namespace ip {
  * @par Examples
  * Setting the option:
  * @code
- * asio::ip::tcp::socket socket(io_service); 
+ * asio::ip::tcp::socket socket(io_context); 
  * ...
  * asio::ip::v6_only option(true);
  * socket.set_option(option);
@@ -40,7 +40,7 @@ namespace ip {
  * @par
  * Getting the current option value:
  * @code
- * asio::ip::tcp::socket socket(io_service); 
+ * asio::ip::tcp::socket socket(io_context); 
  * ...
  * asio::ip::v6_only option;
  * socket.get_option(option);
diff --git a/extern/include/asio/is_executor.hpp b/extern/include/asio/is_executor.hpp
new file mode 100644
index 00000000..a1661ec4
--- /dev/null
+++ b/extern/include/asio/is_executor.hpp
@@ -0,0 +1,46 @@
+//
+// is_executor.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_IS_EXECUTOR_HPP
+#define ASIO_IS_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/is_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// The is_executor trait detects whether a type T meets the Executor type
+/// requirements.
+/**
+ * Class template @c is_executor is a UnaryTypeTrait that is derived from @c
+ * true_type if the type @c T meets the syntactic requirements for Executor,
+ * otherwise @c false_type.
+ */
+template <typename T>
+struct is_executor
+#if defined(GENERATING_DOCUMENTATION)
+  : integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  : asio::detail::is_executor<T>
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IS_EXECUTOR_HPP
diff --git a/extern/include/asio/is_read_buffered.hpp b/extern/include/asio/is_read_buffered.hpp
index 5fcfa944..c5a67b2d 100644
--- a/extern/include/asio/is_read_buffered.hpp
+++ b/extern/include/asio/is_read_buffered.hpp
@@ -2,7 +2,7 @@
 // is_read_buffered.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/is_write_buffered.hpp b/extern/include/asio/is_write_buffered.hpp
index 2f71b1d7..e237dd6f 100644
--- a/extern/include/asio/is_write_buffered.hpp
+++ b/extern/include/asio/is_write_buffered.hpp
@@ -2,7 +2,7 @@
 // is_write_buffered.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/local/basic_endpoint.hpp b/extern/include/asio/local/basic_endpoint.hpp
index 9a19ab01..94e470a4 100644
--- a/extern/include/asio/local/basic_endpoint.hpp
+++ b/extern/include/asio/local/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // local/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/extern/include/asio/local/connect_pair.hpp b/extern/include/asio/local/connect_pair.hpp
index 2d785d5b..2f7c090e 100644
--- a/extern/include/asio/local/connect_pair.hpp
+++ b/extern/include/asio/local/connect_pair.hpp
@@ -2,7 +2,7 @@
 // local/connect_pair.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -32,32 +32,32 @@ namespace asio {
 namespace local {
 
 /// Create a pair of connected sockets.
-template <typename Protocol, typename SocketService1, typename SocketService2>
+template <typename Protocol ASIO_SVC_TPARAM ASIO_SVC_TPARAM1>
 void connect_pair(
-    basic_socket<Protocol, SocketService1>& socket1,
-    basic_socket<Protocol, SocketService2>& socket2);
+    basic_socket<Protocol ASIO_SVC_TARG>& socket1,
+    basic_socket<Protocol ASIO_SVC_TARG1>& socket2);
 
 /// Create a pair of connected sockets.
-template <typename Protocol, typename SocketService1, typename SocketService2>
-asio::error_code connect_pair(
-    basic_socket<Protocol, SocketService1>& socket1,
-    basic_socket<Protocol, SocketService2>& socket2,
+template <typename Protocol ASIO_SVC_TPARAM ASIO_SVC_TPARAM1>
+ASIO_SYNC_OP_VOID connect_pair(
+    basic_socket<Protocol ASIO_SVC_TARG>& socket1,
+    basic_socket<Protocol ASIO_SVC_TARG1>& socket2,
     asio::error_code& ec);
 
-template <typename Protocol, typename SocketService1, typename SocketService2>
+template <typename Protocol ASIO_SVC_TPARAM ASIO_SVC_TPARAM1>
 inline void connect_pair(
-    basic_socket<Protocol, SocketService1>& socket1,
-    basic_socket<Protocol, SocketService2>& socket2)
+    basic_socket<Protocol ASIO_SVC_TARG>& socket1,
+    basic_socket<Protocol ASIO_SVC_TARG1>& socket2)
 {
   asio::error_code ec;
   connect_pair(socket1, socket2, ec);
   asio::detail::throw_error(ec, "connect_pair");
 }
 
-template <typename Protocol, typename SocketService1, typename SocketService2>
-inline asio::error_code connect_pair(
-    basic_socket<Protocol, SocketService1>& socket1,
-    basic_socket<Protocol, SocketService2>& socket2,
+template <typename Protocol ASIO_SVC_TPARAM ASIO_SVC_TPARAM1>
+inline ASIO_SYNC_OP_VOID connect_pair(
+    basic_socket<Protocol ASIO_SVC_TARG>& socket1,
+    basic_socket<Protocol ASIO_SVC_TARG1>& socket2,
     asio::error_code& ec)
 {
   // Check that this function is only being used with a UNIX domain socket.
@@ -70,27 +70,29 @@ inline asio::error_code connect_pair(
   if (asio::detail::socket_ops::socketpair(protocol.family(),
         protocol.type(), protocol.protocol(), sv, ec)
       == asio::detail::socket_error_retval)
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
 
-  if (socket1.assign(protocol, sv[0], ec))
+  socket1.assign(protocol, sv[0], ec);
+  if (ec)
   {
     asio::error_code temp_ec;
     asio::detail::socket_ops::state_type state[2] = { 0, 0 };
     asio::detail::socket_ops::close(sv[0], state[0], true, temp_ec);
     asio::detail::socket_ops::close(sv[1], state[1], true, temp_ec);
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  if (socket2.assign(protocol, sv[1], ec))
+  socket2.assign(protocol, sv[1], ec);
+  if (ec)
   {
     asio::error_code temp_ec;
     socket1.close(temp_ec);
     asio::detail::socket_ops::state_type state = 0;
     asio::detail::socket_ops::close(sv[1], state, true, temp_ec);
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 } // namespace local
diff --git a/extern/include/asio/local/datagram_protocol.hpp b/extern/include/asio/local/datagram_protocol.hpp
index 3fa062c5..b87df2e5 100644
--- a/extern/include/asio/local/datagram_protocol.hpp
+++ b/extern/include/asio/local/datagram_protocol.hpp
@@ -2,7 +2,7 @@
 // local/datagram_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/local/detail/endpoint.hpp b/extern/include/asio/local/detail/endpoint.hpp
index 43c66737..4870f3b9 100644
--- a/extern/include/asio/local/detail/endpoint.hpp
+++ b/extern/include/asio/local/detail/endpoint.hpp
@@ -2,7 +2,7 @@
 // local/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/extern/include/asio/local/detail/impl/endpoint.ipp b/extern/include/asio/local/detail/impl/endpoint.ipp
index aad7556d..d5bbf503 100644
--- a/extern/include/asio/local/detail/impl/endpoint.ipp
+++ b/extern/include/asio/local/detail/impl/endpoint.ipp
@@ -2,7 +2,7 @@
 // local/detail/impl/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -108,7 +108,8 @@ void endpoint::init(const char* path_name, std::size_t path_length)
   using namespace std; // For memcpy.
   data_.local = asio::detail::sockaddr_un_type();
   data_.local.sun_family = AF_UNIX;
-  memcpy(data_.local.sun_path, path_name, path_length);
+  if (path_length > 0)
+    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/extern/include/asio/local/stream_protocol.hpp b/extern/include/asio/local/stream_protocol.hpp
index 7fe97727..e2ef5f3b 100644
--- a/extern/include/asio/local/stream_protocol.hpp
+++ b/extern/include/asio/local/stream_protocol.hpp
@@ -2,7 +2,7 @@
 // local/stream_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/packaged_task.hpp b/extern/include/asio/packaged_task.hpp
new file mode 100644
index 00000000..1e20b42e
--- /dev/null
+++ b/extern/include/asio/packaged_task.hpp
@@ -0,0 +1,126 @@
+//
+// packaged_task.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_PACKAGED_TASK_HPP
+#define ASIO_PACKAGED_TASK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_STD_FUTURE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <future>
+#include "asio/async_result.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/detail/variadic_templates.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Partial specialisation of @c async_result for @c std::packaged_task.
+template <typename Result, typename... Args, typename Signature>
+class async_result<std::packaged_task<Result(Args...)>, Signature>
+{
+public:
+  /// The packaged task is the concrete completion handler type.
+  typedef std::packaged_task<Result(Args...)> completion_handler_type;
+
+  /// The return type of the initiating function is the future obtained from
+  /// the packaged task.
+  typedef std::future<Result> return_type;
+
+  /// The constructor extracts the future from the packaged task.
+  explicit async_result(completion_handler_type& h)
+    : future_(h.get_future())
+  {
+  }
+
+  /// Returns the packaged task's future.
+  return_type get()
+  {
+    return std::move(future_);
+  }
+
+private:
+  return_type future_;
+};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+      //   || defined(GENERATING_DOCUMENTATION)
+
+template <typename Result, typename Signature>
+struct async_result<std::packaged_task<Result()>, Signature>
+{
+  typedef std::packaged_task<Result()> completion_handler_type;
+  typedef std::future<Result> return_type;
+
+  explicit async_result(completion_handler_type& h)
+    : future_(h.get_future())
+  {
+  }
+
+  return_type get()
+  {
+    return std::move(future_);
+  }
+
+private:
+  return_type future_;
+};
+
+#define ASIO_PRIVATE_ASYNC_RESULT_DEF(n) \
+  template <typename Result, \
+    ASIO_VARIADIC_TPARAMS(n), typename Signature> \
+  class async_result< \
+    std::packaged_task<Result(ASIO_VARIADIC_TARGS(n))>, Signature> \
+  { \
+  public: \
+    typedef std::packaged_task< \
+      Result(ASIO_VARIADIC_TARGS(n))> \
+        completion_handler_type; \
+  \
+    typedef std::future<Result> return_type; \
+  \
+    explicit async_result(completion_handler_type& h) \
+      : future_(h.get_future()) \
+    { \
+    } \
+  \
+    return_type get() \
+    { \
+      return std::move(future_); \
+    } \
+  \
+  private: \
+    return_type future_; \
+  }; \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_ASYNC_RESULT_DEF)
+#undef ASIO_PRIVATE_ASYNC_RESULT_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_STD_FUTURE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // ASIO_PACKAGED_TASK_HPP
diff --git a/extern/include/asio/placeholders.hpp b/extern/include/asio/placeholders.hpp
index 011cf263..e71a21e7 100644
--- a/extern/include/asio/placeholders.hpp
+++ b/extern/include/asio/placeholders.hpp
@@ -2,7 +2,7 @@
 // placeholders.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -40,9 +40,19 @@ unspecified bytes_transferred;
 
 /// An argument placeholder, for use with boost::bind(), that corresponds to
 /// the iterator argument of a handler for asynchronous functions such as
-/// asio::basic_resolver::async_resolve.
+/// asio::async_connect.
 unspecified iterator;
 
+/// An argument placeholder, for use with boost::bind(), that corresponds to
+/// the results argument of a handler for asynchronous functions such as
+/// asio::basic_resolver::async_resolve.
+unspecified results;
+
+/// An argument placeholder, for use with boost::bind(), that corresponds to
+/// the results argument of a handler for asynchronous functions such as
+/// asio::async_connect.
+unspecified endpoint;
+
 /// An argument placeholder, for use with boost::bind(), that corresponds to
 /// the signal_number argument of a handler for asynchronous functions such as
 /// asio::signal_set::async_wait.
@@ -66,6 +76,16 @@ inline boost::arg<2> iterator()
   return boost::arg<2>();
 }
 
+inline boost::arg<2> results()
+{
+  return boost::arg<2>();
+}
+
+inline boost::arg<2> endpoint()
+{
+  return boost::arg<2>();
+}
+
 inline boost::arg<2> signal_number()
 {
   return boost::arg<2>();
@@ -94,6 +114,10 @@ static boost::arg<2>& bytes_transferred
   = asio::placeholders::detail::placeholder<2>::get();
 static boost::arg<2>& iterator
   = asio::placeholders::detail::placeholder<2>::get();
+static boost::arg<2>& results
+  = asio::placeholders::detail::placeholder<2>::get();
+static boost::arg<2>& endpoint
+  = asio::placeholders::detail::placeholder<2>::get();
 static boost::arg<2>& signal_number
   = asio::placeholders::detail::placeholder<2>::get();
 
@@ -107,6 +131,10 @@ namespace
     = asio::placeholders::detail::placeholder<2>::get();
   boost::arg<2>& iterator
     = asio::placeholders::detail::placeholder<2>::get();
+  boost::arg<2>& results
+    = asio::placeholders::detail::placeholder<2>::get();
+  boost::arg<2>& endpoint
+    = asio::placeholders::detail::placeholder<2>::get();
   boost::arg<2>& signal_number
     = asio::placeholders::detail::placeholder<2>::get();
 } // namespace
diff --git a/extern/include/asio/posix/basic_descriptor.hpp b/extern/include/asio/posix/basic_descriptor.hpp
index f3da28e2..c15da632 100644
--- a/extern/include/asio/posix/basic_descriptor.hpp
+++ b/extern/include/asio/posix/basic_descriptor.hpp
@@ -2,7 +2,7 @@
 // posix/basic_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -45,10 +47,6 @@ 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_handle_type native_handle_type;
 
@@ -59,12 +57,12 @@ class basic_descriptor
   /**
    * This constructor creates a descriptor without opening it.
    *
-   * @param io_service The io_service object that the descriptor will use to
+   * @param io_context The io_context object that the descriptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    */
-  explicit basic_descriptor(asio::io_service& io_service)
-    : basic_io_object<DescriptorService>(io_service)
+  explicit basic_descriptor(asio::io_context& io_context)
+    : basic_io_object<DescriptorService>(io_context)
   {
   }
 
@@ -73,7 +71,7 @@ class basic_descriptor
    * This constructor creates a descriptor object to hold an existing native
    * descriptor.
    *
-   * @param io_service The io_service object that the descriptor will use to
+   * @param io_context The io_context object that the descriptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    *
@@ -81,9 +79,9 @@ class basic_descriptor
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_descriptor(asio::io_service& io_service,
+  basic_descriptor(asio::io_context& io_context,
       const native_handle_type& native_descriptor)
-    : basic_io_object<DescriptorService>(io_service)
+    : basic_io_object<DescriptorService>(io_context)
   {
     asio::error_code ec;
     this->get_service().assign(this->get_implementation(),
@@ -100,7 +98,7 @@ class basic_descriptor
    * 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.
+   * constructed using the @c basic_descriptor(io_context&) constructor.
    */
   basic_descriptor(basic_descriptor&& other)
     : basic_io_object<DescriptorService>(
@@ -116,7 +114,7 @@ class basic_descriptor
    * 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.
+   * constructed using the @c basic_descriptor(io_context&) constructor.
    */
   basic_descriptor& operator=(basic_descriptor&& other)
   {
@@ -178,17 +176,18 @@ class basic_descriptor
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code assign(const native_handle_type& native_descriptor,
+  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_descriptor,
       asio::error_code& ec)
   {
-    return this->get_service().assign(
+    this->get_service().assign(
         this->get_implementation(), native_descriptor, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the descriptor is open.
   bool is_open() const
   {
-    return this->get_service().is_open(this->implementation);
+    return this->get_service().is_open(this->get_implementation());
   }
 
   /// Close the descriptor.
@@ -216,21 +215,10 @@ class basic_descriptor
    * @param ec Set to indicate what error occurred, if any. Note that, even if
    * the function indicates an error, the underlying descriptor is closed.
    */
-  asio::error_code close(asio::error_code& ec)
-  {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (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
-   * functionality that is not otherwise provided.
-   */
-  native_type native()
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return this->get_service().native_handle(this->implementation);
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native descriptor representation.
@@ -241,7 +229,7 @@ class basic_descriptor
    */
   native_handle_type native_handle()
   {
-    return this->get_service().native_handle(this->implementation);
+    return this->get_service().native_handle(this->get_implementation());
   }
 
   /// Release ownership of the native descriptor implementation.
@@ -256,7 +244,7 @@ class basic_descriptor
    */
   native_handle_type release()
   {
-    return this->get_service().release(this->implementation);
+    return this->get_service().release(this->get_implementation());
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
@@ -282,9 +270,10 @@ class basic_descriptor
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code cancel(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the descriptor.
@@ -302,7 +291,7 @@ class basic_descriptor
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
-   * asio::posix::stream_descriptor descriptor(io_service);
+   * asio::posix::stream_descriptor descriptor(io_context);
    * ...
    * asio::posix::stream_descriptor::bytes_readable command;
    * descriptor.io_control(command);
@@ -332,7 +321,7 @@ class basic_descriptor
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
-   * asio::posix::stream_descriptor descriptor(io_service);
+   * asio::posix::stream_descriptor descriptor(io_context);
    * ...
    * asio::posix::stream_descriptor::bytes_readable command;
    * asio::error_code ec;
@@ -345,11 +334,11 @@ class basic_descriptor
    * @endcode
    */
   template <typename IoControlCommand>
-  asio::error_code io_control(IoControlCommand& command,
+  ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
       asio::error_code& ec)
   {
-    return this->get_service().io_control(
-        this->get_implementation(), command, ec);
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the descriptor.
@@ -365,7 +354,7 @@ class basic_descriptor
    */
   bool non_blocking() const
   {
-    return this->get_service().non_blocking(this->implementation);
+    return this->get_service().non_blocking(this->get_implementation());
   }
 
   /// Sets the non-blocking mode of the descriptor.
@@ -401,11 +390,11 @@ class basic_descriptor
    * operations. Asynchronous operations will never fail with the error
    * asio::error::would_block.
    */
-  asio::error_code non_blocking(
+  ASIO_SYNC_OP_VOID non_blocking(
       bool mode, asio::error_code& ec)
   {
-    return this->get_service().non_blocking(
-        this->get_implementation(), mode, ec);
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native descriptor implementation.
@@ -424,7 +413,8 @@ class basic_descriptor
    */
   bool native_non_blocking() const
   {
-    return this->get_service().native_non_blocking(this->implementation);
+    return this->get_service().native_non_blocking(
+        this->get_implementation());
   }
 
   /// Sets the non-blocking mode of the native descriptor implementation.
@@ -465,11 +455,111 @@ class basic_descriptor
    * function fails with asio::error::invalid_argument, as the
    * combination does not make sense.
    */
-  asio::error_code native_non_blocking(
+  ASIO_SYNC_OP_VOID native_non_blocking(
       bool mode, asio::error_code& ec)
   {
-    return this->get_service().native_non_blocking(
+    this->get_service().native_non_blocking(
         this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the descriptor to become ready to read, ready to write, or to
+  /// have pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for a descriptor to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired descriptor state.
+   *
+   * @par Example
+   * Waiting for a descriptor to become readable.
+   * @code
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * descriptor.wait(asio::posix::stream_descriptor::wait_read);
+   * @endcode
+   */
+  void wait(wait_type w)
+  {
+    asio::error_code ec;
+    this->get_service().wait(this->get_implementation(), w, ec);
+    asio::detail::throw_error(ec, "wait");
+  }
+
+  /// Wait for the descriptor to become ready to read, ready to write, or to
+  /// have pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for a descriptor to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired descriptor state.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * Waiting for a descriptor to become readable.
+   * @code
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * asio::error_code ec;
+   * descriptor.wait(asio::posix::stream_descriptor::wait_read, ec);
+   * @endcode
+   */
+  ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
+  {
+    this->get_service().wait(this->get_implementation(), w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the descriptor to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  /**
+   * This function is used to perform an asynchronous wait for a descriptor to
+   * enter a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired descriptor state.
+   *
+   * @param handler The handler to be called when the wait operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error // Result of operation
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void wait_handler(const asio::error_code& error)
+   * {
+   *   if (!error)
+   *   {
+   *     // Wait succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * descriptor.async_wait(
+   *     asio::posix::stream_descriptor::wait_read,
+   *     wait_handler);
+   * @endcode
+   */
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(wait_type w, ASIO_MOVE_ARG(WaitHandler) 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.
+    ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
+
+    return this->get_service().async_wait(this->get_implementation(),
+        w, ASIO_MOVE_CAST(WaitHandler)(handler));
   }
 
 protected:
@@ -487,4 +577,6 @@ class basic_descriptor
 #endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_POSIX_BASIC_DESCRIPTOR_HPP
diff --git a/extern/include/asio/posix/basic_stream_descriptor.hpp b/extern/include/asio/posix/basic_stream_descriptor.hpp
index de19ce60..acd5cb6a 100644
--- a/extern/include/asio/posix/basic_stream_descriptor.hpp
+++ b/extern/include/asio/posix/basic_stream_descriptor.hpp
@@ -2,7 +2,7 @@
 // posix/basic_stream_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -49,10 +51,6 @@ 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_handle_type
     native_handle_type;
@@ -63,12 +61,12 @@ class basic_stream_descriptor
    * descriptor 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 stream descriptor will
+   * @param io_context The io_context object that the stream descriptor will
    * use to dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    */
-  explicit basic_stream_descriptor(asio::io_service& io_service)
-    : basic_descriptor<StreamDescriptorService>(io_service)
+  explicit basic_stream_descriptor(asio::io_context& io_context)
+    : basic_descriptor<StreamDescriptorService>(io_context)
   {
   }
 
@@ -77,7 +75,7 @@ class basic_stream_descriptor
    * This constructor creates a stream descriptor object to hold an existing
    * native descriptor.
    *
-   * @param io_service The io_service object that the stream descriptor will
+   * @param io_context The io_context object that the stream descriptor will
    * use to dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    *
@@ -85,9 +83,9 @@ class basic_stream_descriptor
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_stream_descriptor(asio::io_service& io_service,
+  basic_stream_descriptor(asio::io_context& io_context,
       const native_handle_type& native_descriptor)
-    : basic_descriptor<StreamDescriptorService>(io_service, native_descriptor)
+    : basic_descriptor<StreamDescriptorService>(io_context, native_descriptor)
   {
   }
 
@@ -100,7 +98,7 @@ class basic_stream_descriptor
    * 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.
+   * constructed using the @c basic_stream_descriptor(io_context&) constructor.
    */
   basic_stream_descriptor(basic_stream_descriptor&& other)
     : basic_descriptor<StreamDescriptorService>(
@@ -117,7 +115,7 @@ class basic_stream_descriptor
    * 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.
+   * constructed using the @c basic_stream_descriptor(io_context&) constructor.
    */
   basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
   {
@@ -208,7 +206,7 @@ class basic_stream_descriptor
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
@@ -320,7 +318,7 @@ class basic_stream_descriptor
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
@@ -359,4 +357,6 @@ class basic_stream_descriptor
 #endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
diff --git a/extern/include/asio/posix/descriptor.hpp b/extern/include/asio/posix/descriptor.hpp
new file mode 100644
index 00000000..d0cee1a2
--- /dev/null
+++ b/extern/include/asio/posix/descriptor.hpp
@@ -0,0 +1,644 @@
+//
+// posix/descriptor.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_POSIX_DESCRIPTOR_HPP
+#define ASIO_POSIX_DESCRIPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+
+#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include "asio/async_result.hpp"
+#include "asio/basic_io_object.hpp"
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/reactive_descriptor_service.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+#include "asio/io_context.hpp"
+#include "asio/posix/descriptor_base.hpp"
+
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#define ASIO_SVC_T asio::detail::reactive_descriptor_service
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace posix {
+
+/// Provides POSIX descriptor functionality.
+/**
+ * The posix::descriptor class template provides the ability to wrap a
+ * POSIX descriptor.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class descriptor
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>,
+    public descriptor_base
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
+  /// The native representation of a descriptor.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef ASIO_SVC_T::native_handle_type native_handle_type;
+#endif
+
+  /// A descriptor is always the lowest layer.
+  typedef descriptor lowest_layer_type;
+
+  /// Construct a descriptor without opening it.
+  /**
+   * This constructor creates a descriptor without opening it.
+   *
+   * @param io_context The io_context object that the descriptor will use to
+   * dispatch handlers for any asynchronous operations performed on the
+   * descriptor.
+   */
+  explicit descriptor(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+  }
+
+  /// Construct a descriptor on an existing native descriptor.
+  /**
+   * This constructor creates a descriptor object to hold an existing native
+   * descriptor.
+   *
+   * @param io_context The io_context object that the descriptor will use to
+   * dispatch handlers for any asynchronous operations performed on the
+   * descriptor.
+   *
+   * @param native_descriptor A native descriptor.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  descriptor(asio::io_context& io_context,
+      const native_handle_type& native_descriptor)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(),
+        native_descriptor, ec);
+    asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a descriptor from another.
+  /**
+   * This constructor moves a descriptor from one object to another.
+   *
+   * @param other The other 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 descriptor(io_context&) constructor.
+   */
+  descriptor(descriptor&& other)
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
+  {
+  }
+
+  /// Move-assign a descriptor from another.
+  /**
+   * This assignment operator moves a descriptor from one object to another.
+   *
+   * @param other The other 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 descriptor(io_context&) constructor.
+   */
+  descriptor& operator=(descriptor&& other)
+  {
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since a descriptor cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since a descriptor cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Assign an existing native descriptor to the descriptor.
+  /*
+   * This function opens the descriptor to hold an existing native descriptor.
+   *
+   * @param native_descriptor A native descriptor.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_descriptor)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(),
+        native_descriptor, ec);
+    asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native descriptor to the descriptor.
+  /*
+   * This function opens the descriptor to hold an existing native descriptor.
+   *
+   * @param native_descriptor A native descriptor.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_descriptor,
+      asio::error_code& ec)
+  {
+    this->get_service().assign(
+        this->get_implementation(), native_descriptor, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the descriptor is open.
+  bool is_open() const
+  {
+    return this->get_service().is_open(this->get_implementation());
+  }
+
+  /// Close the descriptor.
+  /**
+   * This function is used to close the descriptor. Any asynchronous read or
+   * write operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
+   */
+  void close()
+  {
+    asio::error_code ec;
+    this->get_service().close(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the descriptor.
+  /**
+   * This function is used to close the descriptor. Any asynchronous read or
+   * write operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
+   */
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
+  {
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// 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->get_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
+   * asio::error::operation_aborted error.
+   */
+  native_handle_type release()
+  {
+    return this->get_service().release(this->get_implementation());
+  }
+
+  /// Cancel all asynchronous operations associated with the descriptor.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    asio::error_code ec;
+    this->get_service().cancel(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the descriptor.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
+  {
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Perform an IO control command on the descriptor.
+  /**
+   * This function is used to execute an IO control command on the descriptor.
+   *
+   * @param command The IO control command to be performed on the descriptor.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @sa IoControlCommand @n
+   * asio::posix::descriptor_base::bytes_readable @n
+   * asio::posix::descriptor_base::non_blocking_io
+   *
+   * @par Example
+   * Getting the number of bytes ready to read:
+   * @code
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * asio::posix::stream_descriptor::bytes_readable command;
+   * descriptor.io_control(command);
+   * std::size_t bytes_readable = command.get();
+   * @endcode
+   */
+  template <typename IoControlCommand>
+  void io_control(IoControlCommand& command)
+  {
+    asio::error_code ec;
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    asio::detail::throw_error(ec, "io_control");
+  }
+
+  /// Perform an IO control command on the descriptor.
+  /**
+   * This function is used to execute an IO control command on the descriptor.
+   *
+   * @param command The IO control command to be performed on the descriptor.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @sa IoControlCommand @n
+   * asio::posix::descriptor_base::bytes_readable @n
+   * asio::posix::descriptor_base::non_blocking_io
+   *
+   * @par Example
+   * Getting the number of bytes ready to read:
+   * @code
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * asio::posix::stream_descriptor::bytes_readable command;
+   * asio::error_code ec;
+   * descriptor.io_control(command, ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * std::size_t bytes_readable = command.get();
+   * @endcode
+   */
+  template <typename IoControlCommand>
+  ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
+      asio::error_code& ec)
+  {
+    this->get_service().io_control(this->get_implementation(), command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Gets the non-blocking mode of the descriptor.
+  /**
+   * @returns @c true if the descriptor's synchronous operations will fail with
+   * 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
+   * asio::error::would_block.
+   */
+  bool non_blocking() const
+  {
+    return this->get_service().non_blocking(this->get_implementation());
+  }
+
+  /// Sets the non-blocking mode of the descriptor.
+  /**
+   * @param mode If @c true, the descriptor's synchronous operations will fail
+   * with asio::error::would_block if they are unable to perform the
+   * requested operation immediately. If @c false, synchronous operations will
+   * block until complete.
+   *
+   * @throws asio::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
+   * asio::error::would_block.
+   */
+  void non_blocking(bool mode)
+  {
+    asio::error_code ec;
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    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 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
+   * asio::error::would_block.
+   */
+  ASIO_SYNC_OP_VOID non_blocking(
+      bool mode, asio::error_code& ec)
+  {
+    this->get_service().non_blocking(this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(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 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->get_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 asio::error::would_block
+   * (or the equivalent system error).
+   *
+   * @throws asio::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 asio::error::invalid_argument, as the
+   * combination does not make sense.
+   */
+  void native_non_blocking(bool mode)
+  {
+    asio::error_code ec;
+    this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
+    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 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 asio::error::invalid_argument, as the
+   * combination does not make sense.
+   */
+  ASIO_SYNC_OP_VOID native_non_blocking(
+      bool mode, asio::error_code& ec)
+  {
+    this->get_service().native_non_blocking(
+        this->get_implementation(), mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the descriptor to become ready to read, ready to write, or to
+  /// have pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for a descriptor to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired descriptor state.
+   *
+   * @par Example
+   * Waiting for a descriptor to become readable.
+   * @code
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * descriptor.wait(asio::posix::stream_descriptor::wait_read);
+   * @endcode
+   */
+  void wait(wait_type w)
+  {
+    asio::error_code ec;
+    this->get_service().wait(this->get_implementation(), w, ec);
+    asio::detail::throw_error(ec, "wait");
+  }
+
+  /// Wait for the descriptor to become ready to read, ready to write, or to
+  /// have pending error conditions.
+  /**
+   * This function is used to perform a blocking wait for a descriptor to enter
+   * a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired descriptor state.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * Waiting for a descriptor to become readable.
+   * @code
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * asio::error_code ec;
+   * descriptor.wait(asio::posix::stream_descriptor::wait_read, ec);
+   * @endcode
+   */
+  ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
+  {
+    this->get_service().wait(this->get_implementation(), w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the descriptor to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  /**
+   * This function is used to perform an asynchronous wait for a descriptor to
+   * enter a ready to read, write or error condition state.
+   *
+   * @param w Specifies the desired descriptor state.
+   *
+   * @param handler The handler to be called when the wait operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error // Result of operation
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @par Example
+   * @code
+   * void wait_handler(const asio::error_code& error)
+   * {
+   *   if (!error)
+   *   {
+   *     // Wait succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * asio::posix::stream_descriptor descriptor(io_context);
+   * ...
+   * descriptor.async_wait(
+   *     asio::posix::stream_descriptor::wait_read,
+   *     wait_handler);
+   * @endcode
+   */
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(wait_type w, ASIO_MOVE_ARG(WaitHandler) 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.
+    ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
+
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_wait(
+        this->get_implementation(), w, init.completion_handler);
+
+    return init.result.get();
+  }
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  /**
+   * This function destroys the descriptor, cancelling any outstanding
+   * asynchronous wait operations associated with the descriptor as if by
+   * calling @c cancel.
+   */
+  ~descriptor()
+  {
+  }
+};
+
+} // namespace posix
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#undef ASIO_SVC_T
+
+#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
+#endif // ASIO_POSIX_DESCRIPTOR_HPP
diff --git a/extern/include/asio/posix/descriptor_base.hpp b/extern/include/asio/posix/descriptor_base.hpp
index 0b3a5ae5..4aac04f1 100644
--- a/extern/include/asio/posix/descriptor_base.hpp
+++ b/extern/include/asio/posix/descriptor_base.hpp
@@ -2,7 +2,7 @@
 // posix/descriptor_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,33 +28,26 @@
 namespace asio {
 namespace posix {
 
-/// The descriptor_base class is used as a base for the basic_stream_descriptor
-/// class template so that we have a common place to define the associated
-/// IO control commands.
+/// The descriptor_base class is used as a base for the descriptor class as a
+/// place to define the associated IO control commands.
 class descriptor_base
 {
 public:
-  /// (Deprecated: Use non_blocking().) IO control command to set the blocking
-  /// mode of the descriptor.
+  /// Wait types.
   /**
-   * Implements the FIONBIO IO control command.
-   *
-   * @par Example
-   * @code
-   * asio::posix::stream_descriptor descriptor(io_service); 
-   * ...
-   * asio::descriptor_base::non_blocking_io command(true);
-   * descriptor.io_control(command);
-   * @endcode
-   *
-   * @par Concepts:
-   * IoControlCommand.
+   * For use with descriptor::wait() and descriptor::async_wait().
    */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined non_blocking_io;
-#else
-  typedef asio::detail::io_control::non_blocking_io non_blocking_io;
-#endif
+  enum wait_type
+  {
+    /// Wait for a descriptor to become ready to read.
+    wait_read,
+
+    /// Wait for a descriptor to become ready to write.
+    wait_write,
+
+    /// Wait for a descriptor to have error conditions pending.
+    wait_error
+  };
 
   /// IO control command to get the amount of data that can be read without
   /// blocking.
@@ -63,7 +56,7 @@ class descriptor_base
    *
    * @par Example
    * @code
-   * asio::posix::stream_descriptor descriptor(io_service); 
+   * asio::posix::stream_descriptor descriptor(io_context); 
    * ...
    * asio::descriptor_base::bytes_readable command(true);
    * descriptor.io_control(command);
diff --git a/extern/include/asio/posix/stream_descriptor.hpp b/extern/include/asio/posix/stream_descriptor.hpp
index 25c62e8d..abb426a3 100644
--- a/extern/include/asio/posix/stream_descriptor.hpp
+++ b/extern/include/asio/posix/stream_descriptor.hpp
@@ -2,7 +2,7 @@
 // posix/stream_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,17 +16,340 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/posix/descriptor.hpp"
 
 #if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
-#include "asio/posix/basic_stream_descriptor.hpp"
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/posix/basic_stream_descriptor.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 namespace asio {
 namespace posix {
 
-/// Typedef for the typical usage of a stream-oriented descriptor.
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+// Typedef for the typical usage of a stream-oriented descriptor.
 typedef basic_stream_descriptor<> stream_descriptor;
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+/// Provides stream-oriented descriptor functionality.
+/**
+ * The posix::stream_descriptor class template provides asynchronous and
+ * blocking stream-oriented descriptor functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
+ */
+class stream_descriptor
+  : public descriptor
+{
+public:
+  /// Construct a stream_descriptor without opening it.
+  /**
+   * This constructor creates a stream descriptor without opening it. The
+   * descriptor needs to be opened and then connected or accepted before data
+   * can be sent or received on it.
+   *
+   * @param io_context The io_context object that the stream descriptor will
+   * use to dispatch handlers for any asynchronous operations performed on the
+   * descriptor.
+   */
+  explicit stream_descriptor(asio::io_context& io_context)
+    : descriptor(io_context)
+  {
+  }
+
+  /// Construct a stream_descriptor on an existing native descriptor.
+  /**
+   * This constructor creates a stream descriptor object to hold an existing
+   * native descriptor.
+   *
+   * @param io_context The io_context object that the stream descriptor will
+   * use to dispatch handlers for any asynchronous operations performed on the
+   * descriptor.
+   *
+   * @param native_descriptor The new underlying descriptor implementation.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  stream_descriptor(asio::io_context& io_context,
+      const native_handle_type& native_descriptor)
+    : descriptor(io_context, native_descriptor)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a stream_descriptor from another.
+  /**
+   * This constructor moves a stream descriptor from one object to another.
+   *
+   * @param other The other 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 stream_descriptor(io_context&) constructor.
+   */
+  stream_descriptor(stream_descriptor&& other)
+    : descriptor(std::move(other))
+  {
+  }
+
+  /// Move-assign a stream_descriptor from another.
+  /**
+   * This assignment operator moves a stream descriptor from one object to
+   * another.
+   *
+   * @param other The other 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 stream_descriptor(io_context&) constructor.
+   */
+  stream_descriptor& operator=(stream_descriptor&& other)
+  {
+    descriptor::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(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
+   * call will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the descriptor.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The write_some 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.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * descriptor.write_some(asio::buffer(data, size));
+   * @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.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+    asio::detail::throw_error(ec, "write_some");
+    return s;
+  }
+
+  /// Write some data to the descriptor.
+  /**
+   * This function is used to write data to the stream descriptor. The function
+   * call will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the descriptor.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some 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 write_some(const ConstBufferSequence& buffers,
+      asio::error_code& ec)
+  {
+    return this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the stream
+   * descriptor. The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be written to the descriptor.
+   * 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 handler The handler to be called when the write operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes written.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write function if you need to ensure that all
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * descriptor.async_write_some(asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename ConstBufferSequence, typename WriteHandler>
+  ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (asio::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      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.
+    ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    asio::async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_write_some(
+        this->get_implementation(), buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+
+  /// Read some data from the descriptor.
+  /**
+   * This function is used to read data from the stream descriptor. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The read_some operation may not read 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 read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * descriptor.read_some(asio::buffer(data, size));
+   * @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.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+    asio::detail::throw_error(ec, "read_some");
+    return s;
+  }
+
+  /// Read some data from the descriptor.
+  /**
+   * This function is used to read data from the stream descriptor. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read 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 read_some(const MutableBufferSequence& buffers,
+      asio::error_code& ec)
+  {
+    return this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the stream
+   * descriptor. The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * 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 handler The handler to be called when the read operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes read.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read function if you need to ensure that the
+   * requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * descriptor.async_read_some(asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename MutableBufferSequence, typename ReadHandler>
+  ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (asio::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      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.
+    ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    asio::async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_read_some(
+        this->get_implementation(), buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+};
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 } // namespace posix
 } // namespace asio
diff --git a/extern/include/asio/posix/stream_descriptor_service.hpp b/extern/include/asio/posix/stream_descriptor_service.hpp
index 56cd1c37..4ffbb960 100644
--- a/extern/include/asio/posix/stream_descriptor_service.hpp
+++ b/extern/include/asio/posix/stream_descriptor_service.hpp
@@ -2,7 +2,7 @@
 // posix/stream_descriptor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,13 +17,15 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
 #include "asio/async_result.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/detail/reactive_descriptor_service.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -34,7 +36,7 @@ namespace posix {
 /// Default service implementation for a stream descriptor.
 class stream_descriptor_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<stream_descriptor_service>
 #endif
@@ -42,7 +44,7 @@ class stream_descriptor_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
 private:
@@ -57,13 +59,6 @@ class stream_descriptor_service
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native descriptor type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native descriptor type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_handle_type;
@@ -71,10 +66,10 @@ class stream_descriptor_service
   typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new stream descriptor service for the specified io_service.
-  explicit stream_descriptor_service(asio::io_service& io_service)
-    : asio::detail::service_base<stream_descriptor_service>(io_service),
-      service_impl_(io_service)
+  /// Construct a new stream descriptor service for the specified io_context.
+  explicit stream_descriptor_service(asio::io_context& io_context)
+    : asio::detail::service_base<stream_descriptor_service>(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -108,11 +103,12 @@ class stream_descriptor_service
   }
 
   /// Assign an existing native descriptor to a stream descriptor.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const native_handle_type& native_descriptor,
       asio::error_code& ec)
   {
-    return service_impl_.assign(impl, native_descriptor, ec);
+    service_impl_.assign(impl, native_descriptor, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the descriptor is open.
@@ -122,17 +118,11 @@ class stream_descriptor_service
   }
 
   /// Close a stream descriptor implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native descriptor
-  /// implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native descriptor implementation.
@@ -148,18 +138,20 @@ class stream_descriptor_service
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the descriptor.
   template <typename IoControlCommand>
-  asio::error_code io_control(implementation_type& impl,
+  ASIO_SYNC_OP_VOID io_control(implementation_type& impl,
       IoControlCommand& command, asio::error_code& ec)
   {
-    return service_impl_.io_control(impl, command, ec);
+    service_impl_.io_control(impl, command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the descriptor.
@@ -169,10 +161,11 @@ class stream_descriptor_service
   }
 
   /// Sets the non-blocking mode of the descriptor.
-  asio::error_code non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.non_blocking(impl, mode, ec);
+    service_impl_.non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native descriptor implementation.
@@ -182,10 +175,36 @@ class stream_descriptor_service
   }
 
   /// Sets the non-blocking mode of the native descriptor implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID native_non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.native_non_blocking(impl, mode, ec);
+    service_impl_.native_non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the descriptor to become ready to read, ready to write, or to
+  /// have pending error conditions.
+  ASIO_SYNC_OP_VOID wait(implementation_type& impl,
+      descriptor_base::wait_type w, asio::error_code& ec)
+  {
+    service_impl_.wait(impl, w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the descriptor to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(implementation_type& impl, descriptor_base::wait_type w,
+      ASIO_MOVE_ARG(WaitHandler) handler)
+  {
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    service_impl_.async_wait(impl, w, init.completion_handler);
+
+    return init.result.get();
   }
 
   /// Write the given data to the stream.
@@ -204,11 +223,10 @@ class stream_descriptor_service
       const ConstBufferSequence& buffers,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    asio::detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    asio::async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_write_some(impl, buffers, init.handler);
+    service_impl_.async_write_some(impl, buffers, init.completion_handler);
 
     return init.result.get();
   }
@@ -229,20 +247,19 @@ class stream_descriptor_service
       const MutableBufferSequence& buffers,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    asio::detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    asio::async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_read_some(impl, buffers, init.handler);
+    service_impl_.async_read_some(impl, buffers, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -257,4 +274,6 @@ class stream_descriptor_service
 #endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_POSIX_STREAM_DESCRIPTOR_SERVICE_HPP
diff --git a/extern/include/asio/post.hpp b/extern/include/asio/post.hpp
new file mode 100644
index 00000000..87d7b96d
--- /dev/null
+++ b/extern/include/asio/post.hpp
@@ -0,0 +1,107 @@
+//
+// post.hpp
+// ~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_POST_HPP
+#define ASIO_POST_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/async_result.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/is_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// Submits a completion token or function object for execution.
+/**
+ * This function submits an object for execution using the object's associated
+ * executor. The function object is queued for execution, and is never called
+ * from the current thread prior to returning from <tt>post()</tt>.
+ *
+ * This function has the following effects:
+ *
+ * @li Constructs a function object handler of type @c Handler, initialized
+ * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ *
+ * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
+ * initializing the object as <tt>result(handler)</tt>.
+ *
+ * @li Obtains the handler's associated executor object @c ex by performing
+ * <tt>get_associated_executor(handler)</tt>.
+ *
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * <tt>get_associated_allocator(handler)</tt>.
+ *
+ * @li Performs <tt>ex.post(std::move(handler), alloc)</tt>.
+ *
+ * @li Returns <tt>result.get()</tt>.
+ */
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
+    ASIO_MOVE_ARG(CompletionToken) token);
+
+/// Submits a completion token or function object for execution.
+/**
+ * This function submits an object for execution using the specified executor.
+ * The function object is queued for execution, and is never called from the
+ * current thread prior to returning from <tt>post()</tt>.
+ *
+ * This function has the following effects:
+ *
+ * @li Constructs a function object handler of type @c Handler, initialized
+ * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ *
+ * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
+ * initializing the object as <tt>result(handler)</tt>.
+ *
+ * @li Obtains the handler's associated executor object @c ex1 by performing
+ * <tt>get_associated_executor(handler)</tt>.
+ *
+ * @li Creates a work object @c w by performing <tt>make_work(ex1)</tt>.
+ *
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * <tt>get_associated_allocator(handler)</tt>.
+ *
+ * @li Constructs a function object @c f with a function call operator that
+ * performs <tt>ex1.dispatch(std::move(handler), alloc)</tt> followed by
+ * <tt>w.reset()</tt>.
+ *
+ * @li Performs <tt>Executor(ex).post(std::move(f), alloc)</tt>.
+ *
+ * @li Returns <tt>result.get()</tt>.
+ */
+template <typename Executor, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
+    const Executor& ex, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_executor<Executor>::value>::type* = 0);
+
+/// Submits a completion token or function object for execution.
+/**
+ * @returns <tt>post(ctx.get_executor(), forward<CompletionToken>(token))</tt>.
+ */
+template <typename ExecutionContext, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
+    ExecutionContext& ctx, ASIO_MOVE_ARG(CompletionToken) token,
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type* = 0);
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/post.hpp"
+
+#endif // ASIO_POST_HPP
diff --git a/extern/include/asio/raw_socket_service.hpp b/extern/include/asio/raw_socket_service.hpp
index fcc13160..2bccf032 100644
--- a/extern/include/asio/raw_socket_service.hpp
+++ b/extern/include/asio/raw_socket_service.hpp
@@ -2,7 +2,7 @@
 // raw_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include <cstddef>
 #include "asio/async_result.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/null_socket_service.hpp"
@@ -38,7 +41,7 @@ namespace asio {
 template <typename Protocol>
 class raw_socket_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<raw_socket_service<Protocol> >
 #endif
@@ -46,7 +49,7 @@ class raw_socket_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The protocol type.
@@ -73,13 +76,6 @@ class raw_socket_service
   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;
@@ -87,11 +83,11 @@ class raw_socket_service
   typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new raw socket service for the specified io_service.
-  explicit raw_socket_service(asio::io_service& io_service)
+  /// Construct a new raw socket service for the specified io_context.
+  explicit raw_socket_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        raw_socket_service<Protocol> >(io_service),
-      service_impl_(io_service)
+        raw_socket_service<Protocol> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -117,17 +113,21 @@ class raw_socket_service
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
 
+  // All socket services have access to each other's implementations.
+  template <typename Protocol1> friend class raw_socket_service;
+
   /// Move-construct a new raw socket implementation from another protocol
   /// type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      raw_socket_service<Protocol1>& other_service,
       typename raw_socket_service<
         Protocol1>::implementation_type& other_impl,
       typename enable_if<is_convertible<
         Protocol1, Protocol>::value>::type* = 0)
   {
     service_impl_.template converting_move_construct<Protocol1>(
-        impl, other_impl);
+        impl, other_service.service_impl_, other_impl);
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
@@ -138,22 +138,23 @@ class raw_socket_service
   }
 
   // Open a new raw socket implementation.
-  asio::error_code open(implementation_type& impl,
+  ASIO_SYNC_OP_VOID open(implementation_type& impl,
       const protocol_type& protocol, asio::error_code& ec)
   {
     if (protocol.type() == ASIO_OS_DEF(SOCK_RAW))
       service_impl_.open(impl, protocol, ec);
     else
       ec = asio::error::invalid_argument;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native socket to a raw socket.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const protocol_type& protocol, const native_handle_type& native_socket,
       asio::error_code& ec)
   {
-    return service_impl_.assign(impl, protocol, native_socket, ec);
+    service_impl_.assign(impl, protocol, native_socket, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is open.
@@ -163,16 +164,18 @@ class raw_socket_service
   }
 
   /// Close a raw socket implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
+  /// Release ownership of the underlying socket.
+  native_handle_type release(implementation_type& impl,
+      asio::error_code& ec)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.release(impl, ec);
   }
 
   /// Get the native socket implementation.
@@ -182,10 +185,11 @@ class raw_socket_service
   }
 
   /// Cancel all asynchronous operations associated with the socket.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
@@ -203,17 +207,19 @@ class raw_socket_service
   }
 
   // Bind the raw socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
+  ASIO_SYNC_OP_VOID bind(implementation_type& impl,
       const endpoint_type& endpoint, asio::error_code& ec)
   {
-    return service_impl_.bind(impl, endpoint, ec);
+    service_impl_.bind(impl, endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Connect the raw socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
+  ASIO_SYNC_OP_VOID connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, asio::error_code& ec)
   {
-    return service_impl_.connect(impl, peer_endpoint, ec);
+    service_impl_.connect(impl, peer_endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous connect.
@@ -224,37 +230,39 @@ class raw_socket_service
       const endpoint_type& peer_endpoint,
       ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    detail::async_result_init<
-      ConnectHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(ConnectHandler)(handler));
+    async_completion<ConnectHandler,
+      void (asio::error_code)> init(handler);
 
-    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+    service_impl_.async_connect(impl, peer_endpoint, init.completion_handler);
 
     return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
-  asio::error_code set_option(implementation_type& impl,
+  ASIO_SYNC_OP_VOID set_option(implementation_type& impl,
       const SettableSocketOption& option, asio::error_code& ec)
   {
-    return service_impl_.set_option(impl, option, ec);
+    service_impl_.set_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
-  asio::error_code get_option(const implementation_type& impl,
+  ASIO_SYNC_OP_VOID get_option(const implementation_type& impl,
       GettableSocketOption& option, asio::error_code& ec) const
   {
-    return service_impl_.get_option(impl, option, ec);
+    service_impl_.get_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
-  asio::error_code io_control(implementation_type& impl,
+  ASIO_SYNC_OP_VOID io_control(implementation_type& impl,
       IoControlCommand& command, asio::error_code& ec)
   {
-    return service_impl_.io_control(impl, command, ec);
+    service_impl_.io_control(impl, command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the socket.
@@ -264,10 +272,11 @@ class raw_socket_service
   }
 
   /// Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.non_blocking(impl, mode, ec);
+    service_impl_.non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native socket implementation.
@@ -277,10 +286,11 @@ class raw_socket_service
   }
 
   /// Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID native_non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.native_non_blocking(impl, mode, ec);
+    service_impl_.native_non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the local endpoint.
@@ -298,10 +308,36 @@ class raw_socket_service
   }
 
   /// Disable sends or receives on the socket.
-  asio::error_code shutdown(implementation_type& impl,
+  ASIO_SYNC_OP_VOID shutdown(implementation_type& impl,
       socket_base::shutdown_type what, asio::error_code& ec)
   {
-    return service_impl_.shutdown(impl, what, ec);
+    service_impl_.shutdown(impl, what, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the socket to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  ASIO_SYNC_OP_VOID wait(implementation_type& impl,
+      socket_base::wait_type w, asio::error_code& ec)
+  {
+    service_impl_.wait(impl, w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the socket to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(implementation_type& impl, socket_base::wait_type w,
+      ASIO_MOVE_ARG(WaitHandler) handler)
+  {
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    service_impl_.async_wait(impl, w, init.completion_handler);
+
+    return init.result.get();
   }
 
   /// Send the given data to the peer.
@@ -321,11 +357,10 @@ class raw_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_send(impl, buffers, flags, init.handler);
+    service_impl_.async_send(impl, buffers, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -348,12 +383,11 @@ class raw_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     service_impl_.async_send_to(impl, buffers,
-        destination, flags, init.handler);
+        destination, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -376,11 +410,10 @@ class raw_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_receive(impl, buffers, flags, init.handler);
+    service_impl_.async_receive(impl, buffers, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -404,21 +437,20 @@ class raw_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     service_impl_.async_receive_from(impl, buffers,
-        sender_endpoint, flags, init.handler);
+        sender_endpoint, flags, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -429,4 +461,6 @@ class raw_socket_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_RAW_SOCKET_SERVICE_HPP
diff --git a/extern/include/asio/read.hpp b/extern/include/asio/read.hpp
index a68b6c06..e77206a8 100644
--- a/extern/include/asio/read.hpp
+++ b/extern/include/asio/read.hpp
@@ -2,7 +2,7 @@
 // read.hpp
 // ~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,9 +18,13 @@
 #include "asio/detail/config.hpp"
 #include <cstddef>
 #include "asio/async_result.hpp"
-#include "asio/basic_streambuf_fwd.hpp"
+#include "asio/buffer.hpp"
 #include "asio/error.hpp"
 
+#if !defined(ASIO_NO_EXTENSIONS)
+# include "asio/basic_streambuf_fwd.hpp"
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -70,7 +74,10 @@ namespace asio {
  *     asio::transfer_all()); @endcode
  */
 template <typename SyncReadStream, typename MutableBufferSequence>
-std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
+std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type* = 0);
 
 /// Attempt to read a certain amount of data from a stream before returning.
 /**
@@ -110,7 +117,10 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
  */
 template <typename SyncReadStream, typename MutableBufferSequence>
 std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    asio::error_code& ec);
+    asio::error_code& ec,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type* = 0);
 
 /// Attempt to read a certain amount of data from a stream before returning.
 /**
@@ -161,7 +171,10 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
 template <typename SyncReadStream, typename MutableBufferSequence,
   typename CompletionCondition>
 std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition);
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type* = 0);
 
 /// Attempt to read a certain amount of data from a stream before returning.
 /**
@@ -205,8 +218,171 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
 template <typename SyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec);
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type* = 0);
+
+/// 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 specified dynamic buffer sequence is full (that is, it has reached
+ * maximum size).
+ *
+ * @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 The dynamic buffer sequence into which the data will be read.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note This overload is equivalent to calling:
+ * @code asio::read(
+ *     s, buffers,
+ *     asio::transfer_all()); @endcode
+ */
+template <typename SyncReadStream, typename DynamicBuffer>
+std::size_t read(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+/// 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 buffer is full (that is, it has reached maximum size).
+ *
+ * @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 The dynamic buffer sequence 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 asio::read(
+ *     s, buffers,
+ *     asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncReadStream, typename DynamicBuffer>
+std::size_t read(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+/// 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 specified dynamic buffer sequence is full (that is, it has reached
+ * maximum size).
+ *
+ * @li The completion_condition function object returns 0.
+ *
+ * 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 The dynamic buffer sequence into which the data will be read.
+ *
+ * @param completion_condition The function object to be called to determine
+ * whether the read operation is complete. The signature of the function object
+ * must be:
+ * @code std::size_t completion_condition(
+ *   // Result of latest read_some operation.
+ *   const asio::error_code& error,
+ *
+ *   // Number of bytes transferred so far.
+ *   std::size_t bytes_transferred
+ * ); @endcode
+ * A return value of 0 indicates that the read operation is complete. A non-zero
+ * return value indicates the maximum number of bytes to be read on the next
+ * call to the stream's read_some function.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws asio::system_error Thrown on failure.
+ */
+template <typename SyncReadStream, typename DynamicBuffer,
+    typename CompletionCondition>
+std::size_t read(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
 
+/// 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 specified dynamic buffer sequence is full (that is, it has reached
+ * maximum size).
+ *
+ * @li The completion_condition function object returns 0.
+ *
+ * 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 The dynamic buffer sequence into which the data will be read.
+ *
+ * @param completion_condition The function object to be called to determine
+ * whether the read operation is complete. The signature of the function object
+ * must be:
+ * @code std::size_t completion_condition(
+ *   // Result of latest read_some operation.
+ *   const asio::error_code& error,
+ *
+ *   // Number of bytes transferred so far.
+ *   std::size_t bytes_transferred
+ * ); @endcode
+ * A return value of 0 indicates that the read operation is complete. A non-zero
+ * return value indicates the maximum number of bytes to be read on the next
+ * call to the stream's read_some function.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes read. If an error occurs, returns the total
+ * number of bytes successfully transferred prior to the error.
+ */
+template <typename SyncReadStream, typename DynamicBuffer,
+    typename CompletionCondition>
+std::size_t read(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Attempt to read a certain amount of data from a stream before returning.
@@ -350,6 +526,7 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, asio::error_code& ec);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 /**
@@ -403,7 +580,7 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
@@ -425,7 +602,10 @@ template <typename AsyncReadStream, typename MutableBufferSequence,
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    ASIO_MOVE_ARG(ReadHandler) handler);
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type* = 0);
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
@@ -478,7 +658,7 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
@@ -496,8 +676,143 @@ ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler);
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_mutable_buffer_sequence<MutableBufferSequence>::value
+    >::type* = 0);
+
+/// Start an asynchronous operation to read a certain amount of data from a
+/// stream.
+/**
+ * This function is used to asynchronously read a certain number of bytes of
+ * data from a stream. The function call always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions is
+ * true:
+ *
+ * @li The specified dynamic buffer sequence is full (that is, it has reached
+ * maximum size).
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * async_read_some function, and is known as a <em>composed operation</em>. The
+ * program must ensure that the stream performs no other read operations (such
+ * as async_read, the stream's async_read_some function, or any other composed
+ * operations that perform reads) until this operation completes.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the AsyncReadStream concept.
+ *
+ * @param buffers The dynamic buffer sequence into which the data will be read.
+ * 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 handler The handler to be called when the read operation completes.
+ * Copies will be made of the handler as required. The function signature of the
+ * handler must be:
+ * @code void handler(
+ *   const asio::error_code& error, // Result of operation.
+ *
+ *   std::size_t bytes_transferred           // Number of bytes copied into the
+ *                                           // buffers. If an error occurred,
+ *                                           // this will be the  number of
+ *                                           // bytes successfully transferred
+ *                                           // prior to the error.
+ * ); @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
+ * asio::io_context::post().
+ *
+ * @note This overload is equivalent to calling:
+ * @code asio::async_read(
+ *     s, buffers,
+ *     asio::transfer_all(),
+ *     handler); @endcode
+ */
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
+ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read(AsyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+/// Start an asynchronous operation to read a certain amount of data from a
+/// stream.
+/**
+ * This function is used to asynchronously read a certain number of bytes of
+ * data from a stream. The function call always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions is
+ * true:
+ *
+ * @li The specified dynamic buffer sequence is full (that is, it has reached
+ * maximum size).
+ *
+ * @li The completion_condition function object returns 0.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * async_read_some function, and is known as a <em>composed operation</em>. The
+ * program must ensure that the stream performs no other read operations (such
+ * as async_read, the stream's async_read_some function, or any other composed
+ * operations that perform reads) until this operation completes.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the AsyncReadStream concept.
+ *
+ * @param buffers The dynamic buffer sequence into which the data will be read.
+ * 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 completion_condition The function object to be called to determine
+ * whether the read operation is complete. The signature of the function object
+ * must be:
+ * @code std::size_t completion_condition(
+ *   // Result of latest async_read_some operation.
+ *   const asio::error_code& error,
+ *
+ *   // Number of bytes transferred so far.
+ *   std::size_t bytes_transferred
+ * ); @endcode
+ * A return value of 0 indicates that the read operation is complete. A non-zero
+ * return value indicates the maximum number of bytes to be read on the next
+ * call to the stream's async_read_some function.
+ *
+ * @param handler The handler to be called when the read operation completes.
+ * Copies will be made of the handler as required. The function signature of the
+ * handler must be:
+ * @code void handler(
+ *   const asio::error_code& error, // Result of operation.
+ *
+ *   std::size_t bytes_transferred           // Number of bytes copied into the
+ *                                           // buffers. If an error occurred,
+ *                                           // this will be the  number of
+ *                                           // bytes successfully transferred
+ *                                           // prior to the error.
+ * ); @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
+ * asio::io_context::post().
+ */
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename CompletionCondition, typename ReadHandler>
+ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read(AsyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition,
+    ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to read a certain amount of data from a
@@ -540,7 +855,7 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @note This overload is equivalent to calling:
  * @code asio::async_read(
@@ -608,7 +923,7 @@ async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  */
 template <typename AsyncReadStream, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
@@ -619,6 +934,7 @@ async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     ASIO_MOVE_ARG(ReadHandler) handler);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 
diff --git a/extern/include/asio/read_at.hpp b/extern/include/asio/read_at.hpp
index 15291fcf..df2c6287 100644
--- a/extern/include/asio/read_at.hpp
+++ b/extern/include/asio/read_at.hpp
@@ -2,7 +2,7 @@
 // read_at.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,10 +18,13 @@
 #include "asio/detail/config.hpp"
 #include <cstddef>
 #include "asio/async_result.hpp"
-#include "asio/basic_streambuf_fwd.hpp"
 #include "asio/detail/cstdint.hpp"
 #include "asio/error.hpp"
 
+#if !defined(ASIO_NO_EXTENSIONS)
+# include "asio/basic_streambuf_fwd.hpp"
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -229,6 +232,7 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition, asio::error_code& ec);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Attempt to read a certain amount of data at the specified offset before
@@ -384,6 +388,7 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
     CompletionCondition completion_condition, asio::error_code& ec);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 /**
@@ -436,7 +441,7 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
@@ -514,7 +519,7 @@ async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
@@ -535,6 +540,7 @@ async_read_at(AsyncRandomAccessReadDevice& d,
     CompletionCondition completion_condition,
     ASIO_MOVE_ARG(ReadHandler) handler);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to read a certain amount of data at the
@@ -574,7 +580,7 @@ async_read_at(AsyncRandomAccessReadDevice& d,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @note This overload is equivalent to calling:
  * @code asio::async_read_at(
@@ -640,7 +646,7 @@ async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  */
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
@@ -652,6 +658,7 @@ async_read_at(AsyncRandomAccessReadDevice& d,
     ASIO_MOVE_ARG(ReadHandler) handler);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 
diff --git a/extern/include/asio/read_until.hpp b/extern/include/asio/read_until.hpp
index b1af67ff..f413d987 100644
--- a/extern/include/asio/read_until.hpp
+++ b/extern/include/asio/read_until.hpp
@@ -2,7 +2,7 @@
 // read_until.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,17 +16,18 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-
 #include <cstddef>
 #include <string>
 #include "asio/async_result.hpp"
-#include "asio/basic_streambuf.hpp"
 #include "asio/detail/regex_fwd.hpp"
+#include "asio/detail/string_view.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
 
+#if !defined(ASIO_NO_EXTENSIONS)
+# include "asio/basic_streambuf_fwd.hpp"
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -66,289 +67,1221 @@ struct is_match_condition
 /**
  * @defgroup read_until asio::read_until
  *
- * @brief Read data into a streambuf until it contains a delimiter, matches a
- * regular expression, or a function object indicates a match.
+ * @brief Read data into a dynamic buffer sequence, or into a streambuf, until
+ * it contains a delimiter, matches a regular expression, or a function object
+ * indicates a match.
  */
 /*@{*/
 
-/// Read data into a streambuf until it contains a specified delimiter.
+/// Read data into a dynamic buffer sequence until it contains a specified
+/// delimiter.
 /**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until the dynamic buffer sequence's get area contains the specified
+ * delimiter. The call will block until one of the following conditions is
+ * true:
  *
- * @li The get area of the streambuf contains the specified delimiter.
+ * @li The get area of the dynamic buffer sequence contains the specified
+ * delimiter.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
+ * read_some function. If the dynamic buffer sequence's get area already
+ * contains the delimiter, the function returns immediately.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
- * @param b A streambuf object into which the data will be read.
+ * @param buffers The dynamic buffer sequence into which the data will be read.
  *
  * @param delim The delimiter character.
  *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter.
+ * @returns The number of bytes in the dynamic buffer sequence's get area up to
+ * and including the delimiter.
  *
  * @throws asio::system_error Thrown on failure.
  *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond the delimiter. An application will
+ * typically leave that data in the dynamic buffer sequence for a subsequent
+ * read_until operation to examine.
  *
  * @par Example
- * To read data into a streambuf until a newline is encountered:
- * @code asio::streambuf b;
- * asio::read_until(s, b, '\n');
- * std::istream is(&b);
- * std::string line;
- * std::getline(is, line); @endcode
- * After the @c read_until operation completes successfully, the buffer @c b
+ * To read data into a @c std::string until a newline is encountered:
+ * @code std::string data;
+ * std::string n = asio::read_until(s,
+ *     asio::dynamic_buffer(data), '\n');
+ * std::string line = data.substr(0, n);
+ * data.erase(0, n); @endcode
+ * After the @c read_until operation completes successfully, the string @c data
  * contains the delimiter:
  * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
+ * The call to @c substr then extracts the data up to and including the
  * delimiter, so that the string @c line contains:
  * @code { 'a', 'b', ..., 'c', '\n' } @endcode
- * The remaining data is left in the buffer @c b as follows:
+ * After the call to @c erase, the remaining data is left in the buffer @c b as
+ * follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c read_until operation.
  */
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim);
+    ASIO_MOVE_ARG(DynamicBuffer) buffers, char delim);
 
-/// Read data into a streambuf until it contains a specified delimiter.
+/// Read data into a dynamic buffer sequence until it contains a specified
+/// delimiter.
 /**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until the dynamic buffer sequence's get area contains the specified
+ * delimiter. The call will block until one of the following conditions is
+ * true:
  *
- * @li The get area of the streambuf contains the specified delimiter.
+ * @li The get area of the dynamic buffer sequence contains the specified
+ * delimiter.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
+ * read_some function. If the dynamic buffer sequence's get area already
+ * contains the delimiter, the function returns immediately.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
- * @param b A streambuf object into which the data will be read.
+ * @param buffers The dynamic buffer sequence into which the data will be read.
  *
  * @param delim The delimiter character.
  *
  * @param ec Set to indicate what error occurred, if any.
  *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter. Returns 0 if an error occurred.
+ * @returns The number of bytes in the dynamic buffer sequence's get area up to
+ * and including the delimiter. Returns 0 if an error occurred.
  *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond the delimiter. An application will
+ * typically leave that data in the dynamic buffer sequence for a subsequent
+ * read_until operation to examine.
  */
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim,
-    asio::error_code& ec);
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    char delim, asio::error_code& ec);
 
-/// Read data into a streambuf until it contains a specified delimiter.
+/// Read data into a dynamic buffer sequence until it contains a specified
+/// delimiter.
 /**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until the dynamic buffer sequence's get area contains the specified
+ * delimiter. The call will block until one of the following conditions is
+ * true:
  *
- * @li The get area of the streambuf contains the specified delimiter.
+ * @li The get area of the dynamic buffer sequence contains the specified
+ * delimiter.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
+ * read_some function. If the dynamic buffer sequence's get area already
+ * contains the delimiter, the function returns immediately.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
- * @param b A streambuf object into which the data will be read.
+ * @param buffers The dynamic buffer sequence into which the data will be read.
  *
  * @param delim The delimiter string.
  *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter.
- *
- * @throws asio::system_error Thrown on failure.
+ * @returns The number of bytes in the dynamic buffer sequence's get area up to
+ * and including the delimiter.
  *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond the delimiter. An application will
+ * typically leave that data in the dynamic buffer sequence for a subsequent
+ * read_until operation to examine.
  *
  * @par Example
- * To read data into a streambuf until a newline is encountered:
- * @code asio::streambuf b;
- * asio::read_until(s, b, "\r\n");
- * std::istream is(&b);
- * std::string line;
- * std::getline(is, line); @endcode
- * After the @c read_until operation completes successfully, the buffer @c b
+ * To read data into a @c std::string until a CR-LF sequence is encountered:
+ * @code std::string data;
+ * std::string n = asio::read_until(s,
+ *     asio::dynamic_buffer(data), "\r\n");
+ * std::string line = data.substr(0, n);
+ * data.erase(0, n); @endcode
+ * After the @c read_until operation completes successfully, the string @c data
  * contains the delimiter:
  * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
+ * The call to @c substr then extracts the data up to and including the
  * delimiter, so that the string @c line contains:
  * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * The remaining data is left in the buffer @c b as follows:
+ * After the call to @c erase, the remaining data is left in the buffer @c b as
+ * follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c read_until operation.
  */
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const std::string& delim);
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_STRING_VIEW_PARAM delim);
 
-/// Read data into a streambuf until it contains a specified delimiter.
+/// Read data into a dynamic buffer sequence until it contains a specified
+/// delimiter.
 /**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until the dynamic buffer sequence's get area contains the specified
+ * delimiter. The call will block until one of the following conditions is
+ * true:
  *
- * @li The get area of the streambuf contains the specified delimiter.
+ * @li The get area of the dynamic buffer sequence contains the specified
+ * delimiter.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
+ * read_some function. If the dynamic buffer sequence's get area already
+ * contains the delimiter, the function returns immediately.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
- * @param b A streambuf object into which the data will be read.
+ * @param buffers The dynamic buffer sequence into which the data will be read.
  *
  * @param delim The delimiter string.
  *
  * @param ec Set to indicate what error occurred, if any.
  *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter. Returns 0 if an error occurred.
+ * @returns The number of bytes in the dynamic buffer sequence's get area up to
+ * and including the delimiter. Returns 0 if an error occurred.
  *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond the delimiter. An application will
+ * typically leave that data in the dynamic buffer sequence for a subsequent
+ * read_until operation to examine.
  */
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const std::string& delim,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_STRING_VIEW_PARAM delim,
     asio::error_code& ec);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if defined(ASIO_HAS_BOOST_REGEX) \
   || defined(GENERATING_DOCUMENTATION)
 
-/// Read data into a streambuf until some part of the data it contains matches
-/// a regular expression.
+/// Read data into a dynamic buffer sequence until some part of the data it
+/// contains matches a regular expression.
+/**
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until the dynamic buffer sequence's get area contains some data
+ * that matches a regular expression. The call will block until one of the
+ * following conditions is true:
+ *
+ * @li A substring of the dynamic buffer sequence's get area matches the
+ * regular expression.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the dynamic buffer sequence's get area already
+ * contains data that matches the regular expression, the function returns
+ * immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param buffers A dynamic buffer sequence into which the data will be read.
+ *
+ * @param expr The regular expression.
+ *
+ * @returns The number of bytes in the dynamic buffer sequence's get area up to
+ * and including the substring that matches the regular expression.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond that which matched the regular
+ * expression. An application will typically leave that data in the dynamic
+ * buffer sequence for a subsequent read_until operation to examine.
+ *
+ * @par Example
+ * To read data into a @c std::string until a CR-LF sequence is encountered:
+ * @code std::string data;
+ * std::string n = asio::read_until(s,
+ *     asio::dynamic_buffer(data), boost::regex("\r\n"));
+ * std::string line = data.substr(0, n);
+ * data.erase(0, n); @endcode
+ * After the @c read_until operation completes successfully, the string @c data
+ * contains the delimiter:
+ * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
+ * The call to @c substr then extracts the data up to and including the
+ * delimiter, so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
+ * After the call to @c erase, the remaining data is left in the buffer @c b as
+ * follows:
+ * @code { 'd', 'e', ... } @endcode
+ * This data may be the start of a new line, to be extracted by a subsequent
+ * @c read_until operation.
+ */
+template <typename SyncReadStream, typename DynamicBuffer>
+std::size_t read_until(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr);
+
+/// Read data into a dynamic buffer sequence until some part of the data it
+/// contains matches a regular expression.
+/**
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until the dynamic buffer sequence's get area contains some data
+ * that matches a regular expression. The call will block until one of the
+ * following conditions is true:
+ *
+ * @li A substring of the dynamic buffer sequence's get area matches the
+ * regular expression.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the dynamic buffer sequence's get area already
+ * contains data that matches the regular expression, the function returns
+ * immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param buffers A dynamic buffer sequence into which the data will be read.
+ *
+ * @param expr The regular expression.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes in the dynamic buffer sequence's get area up to
+ * and including the substring that matches the regular expression. Returns 0
+ * if an error occurred.
+ *
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond that which matched the regular
+ * expression. An application will typically leave that data in the dynamic
+ * buffer sequence for a subsequent read_until operation to examine.
+ */
+template <typename SyncReadStream, typename DynamicBuffer>
+std::size_t read_until(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr, asio::error_code& ec);
+
+#endif // defined(ASIO_HAS_BOOST_REGEX)
+       // || defined(GENERATING_DOCUMENTATION)
+
+/// Read data into a dynamic buffer sequence until a function object indicates a
+/// match.
+
+/**
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until a user-defined match condition function object, when applied
+ * to the data contained in the dynamic buffer sequence, indicates a successful
+ * match. The call will block until one of the following conditions is true:
+ *
+ * @li The match condition function object returns a std::pair where the second
+ * element evaluates to true.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the match condition function object already indicates
+ * a match, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param buffers A dynamic buffer sequence into which the data will be read.
+ *
+ * @param match_condition The function object to be called to determine whether
+ * a match exists. The signature of the function object must be:
+ * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
+ * @endcode
+ * where @c iterator represents the type:
+ * @code buffers_iterator<typename DynamicBuffer::const_buffers_type>
+ * @endcode
+ * The iterator parameters @c begin and @c end define the range of bytes to be
+ * scanned to determine whether there is a match. The @c first member of the
+ * return value is an iterator marking one-past-the-end of the bytes that have
+ * been consumed by the match function. This iterator is used to calculate the
+ * @c begin parameter for any subsequent invocation of the match condition. The
+ * @c second member of the return value is true if a match has been found, false
+ * otherwise.
+ *
+ * @returns The number of bytes in the dynamic_buffer's get area that
+ * have been fully consumed by the match function.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond that which matched the function object.
+ * An application will typically leave that data in the dynamic buffer sequence
+ * for a subsequent read_until operation to examine.
+
+ * @note The default implementation of the @c is_match_condition type trait
+ * evaluates to true for function pointers and function objects with a
+ * @c result_type typedef. It must be specialised for other user-defined
+ * function objects.
+ *
+ * @par Examples
+ * To read data into a dynamic buffer sequence until whitespace is encountered:
+ * @code typedef asio::buffers_iterator<
+ *     asio::const_buffers_1> iterator;
+ *
+ * std::pair<iterator, bool>
+ * match_whitespace(iterator begin, iterator end)
+ * {
+ *   iterator i = begin;
+ *   while (i != end)
+ *     if (std::isspace(*i++))
+ *       return std::make_pair(i, true);
+ *   return std::make_pair(i, false);
+ * }
+ * ...
+ * std::string data;
+ * asio::read_until(s, data, match_whitespace);
+ * @endcode
+ *
+ * To read data into a @c std::string until a matching character is found:
+ * @code class match_char
+ * {
+ * public:
+ *   explicit match_char(char c) : c_(c) {}
+ *
+ *   template <typename Iterator>
+ *   std::pair<Iterator, bool> operator()(
+ *       Iterator begin, Iterator end) const
+ *   {
+ *     Iterator i = begin;
+ *     while (i != end)
+ *       if (c_ == *i++)
+ *         return std::make_pair(i, true);
+ *     return std::make_pair(i, false);
+ *   }
+ *
+ * private:
+ *   char c_;
+ * };
+ *
+ * namespace asio {
+ *   template <> struct is_match_condition<match_char>
+ *     : public boost::true_type {};
+ * } // namespace asio
+ * ...
+ * std::string data;
+ * asio::read_until(s, data, match_char('a'));
+ * @endcode
+ */
+template <typename SyncReadStream,
+    typename DynamicBuffer, typename MatchCondition>
+std::size_t read_until(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    MatchCondition match_condition,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
+
+/// Read data into a dynamic buffer sequence until a function object indicates a
+/// match.
+/**
+ * This function is used to read data into the specified dynamic buffer
+ * sequence until a user-defined match condition function object, when applied
+ * to the data contained in the dynamic buffer sequence, indicates a successful
+ * match. The call will block until one of the following conditions is true:
+ *
+ * @li The match condition function object returns a std::pair where the second
+ * element evaluates to true.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the match condition function object already indicates
+ * a match, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param buffers A dynamic buffer sequence into which the data will be read.
+ *
+ * @param match_condition The function object to be called to determine whether
+ * a match exists. The signature of the function object must be:
+ * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
+ * @endcode
+ * where @c iterator represents the type:
+ * @code buffers_iterator<DynamicBuffer::const_buffers_type>
+ * @endcode
+ * The iterator parameters @c begin and @c end define the range of bytes to be
+ * scanned to determine whether there is a match. The @c first member of the
+ * return value is an iterator marking one-past-the-end of the bytes that have
+ * been consumed by the match function. This iterator is used to calculate the
+ * @c begin parameter for any subsequent invocation of the match condition. The
+ * @c second member of the return value is true if a match has been found, false
+ * otherwise.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes in the dynamic buffer sequence's get area that
+ * have been fully consumed by the match function. Returns 0 if an error
+ * occurred.
+ *
+ * @note After a successful read_until operation, the dynamic buffer sequence
+ * may contain additional data beyond that which matched the function object.
+ * An application will typically leave that data in the dynamic buffer sequence
+ * for a subsequent read_until operation to examine.
+ *
+ * @note The default implementation of the @c is_match_condition type trait
+ * evaluates to true for function pointers and function objects with a
+ * @c result_type typedef. It must be specialised for other user-defined
+ * function objects.
+ */
+template <typename SyncReadStream,
+    typename DynamicBuffer, typename MatchCondition>
+std::size_t read_until(SyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    MatchCondition match_condition, asio::error_code& ec,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
+
+#if !defined(ASIO_NO_IOSTREAM)
+
+/// Read data into a streambuf until it contains a specified delimiter.
+/**
+ * This function is used to read data into the specified streambuf until the
+ * streambuf's get area contains the specified delimiter. The call will block
+ * until one of the following conditions is true:
+ *
+ * @li The get area of the streambuf contains the specified delimiter.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the streambuf's get area already contains the
+ * delimiter, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param delim The delimiter character.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the delimiter.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond the delimiter. An application will typically leave
+ * that data in the streambuf for a subsequent read_until operation to examine.
+ *
+ * @par Example
+ * To read data into a streambuf until a newline is encountered:
+ * @code asio::streambuf b;
+ * asio::read_until(s, b, '\n');
+ * std::istream is(&b);
+ * std::string line;
+ * std::getline(is, line); @endcode
+ * After the @c read_until operation completes successfully, the buffer @c b
+ * contains the delimiter:
+ * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
+ * The call to @c std::getline then extracts the data up to and including the
+ * newline (which is discarded), so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c' } @endcode
+ * The remaining data is left in the buffer @c b as follows:
+ * @code { 'd', 'e', ... } @endcode
+ * This data may be the start of a new line, to be extracted by a subsequent
+ * @c read_until operation.
+ */
+template <typename SyncReadStream, typename Allocator>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, char delim);
+
+/// Read data into a streambuf until it contains a specified delimiter.
+/**
+ * This function is used to read data into the specified streambuf until the
+ * streambuf's get area contains the specified delimiter. The call will block
+ * until one of the following conditions is true:
+ *
+ * @li The get area of the streambuf contains the specified delimiter.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the streambuf's get area already contains the
+ * delimiter, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param delim The delimiter character.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the delimiter. Returns 0 if an error occurred.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond the delimiter. An application will typically leave
+ * that data in the streambuf for a subsequent read_until operation to examine.
+ */
+template <typename SyncReadStream, typename Allocator>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, char delim,
+    asio::error_code& ec);
+
+/// Read data into a streambuf until it contains a specified delimiter.
+/**
+ * This function is used to read data into the specified streambuf until the
+ * streambuf's get area contains the specified delimiter. The call will block
+ * until one of the following conditions is true:
+ *
+ * @li The get area of the streambuf contains the specified delimiter.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the streambuf's get area already contains the
+ * delimiter, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param delim The delimiter string.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the delimiter.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond the delimiter. An application will typically leave
+ * that data in the streambuf for a subsequent read_until operation to examine.
+ *
+ * @par Example
+ * To read data into a streambuf until a newline is encountered:
+ * @code asio::streambuf b;
+ * asio::read_until(s, b, "\r\n");
+ * std::istream is(&b);
+ * std::string line;
+ * std::getline(is, line); @endcode
+ * After the @c read_until operation completes successfully, the buffer @c b
+ * contains the delimiter:
+ * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
+ * The call to @c std::getline then extracts the data up to and including the
+ * newline (which is discarded), so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c', '\r' } @endcode
+ * The remaining data is left in the buffer @c b as follows:
+ * @code { 'd', 'e', ... } @endcode
+ * This data may be the start of a new line, to be extracted by a subsequent
+ * @c read_until operation.
+ */
+template <typename SyncReadStream, typename Allocator>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    ASIO_STRING_VIEW_PARAM delim);
+
+/// Read data into a streambuf until it contains a specified delimiter.
+/**
+ * This function is used to read data into the specified streambuf until the
+ * streambuf's get area contains the specified delimiter. The call will block
+ * until one of the following conditions is true:
+ *
+ * @li The get area of the streambuf contains the specified delimiter.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the streambuf's get area already contains the
+ * delimiter, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param delim The delimiter string.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the delimiter. Returns 0 if an error occurred.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond the delimiter. An application will typically leave
+ * that data in the streambuf for a subsequent read_until operation to examine.
+ */
+template <typename SyncReadStream, typename Allocator>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec);
+
+#if defined(ASIO_HAS_BOOST_REGEX) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Read data into a streambuf until some part of the data it contains matches
+/// a regular expression.
+/**
+ * This function is used to read data into the specified streambuf until the
+ * streambuf's get area contains some data that matches a regular expression.
+ * The call will block until one of the following conditions is true:
+ *
+ * @li A substring of the streambuf's get area matches the regular expression.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the streambuf's get area already contains data that
+ * matches the regular expression, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param expr The regular expression.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the substring that matches the regular expression.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond that which matched the regular expression. An
+ * application will typically leave that data in the streambuf for a subsequent
+ * read_until operation to examine.
+ *
+ * @par Example
+ * To read data into a streambuf until a CR-LF sequence is encountered:
+ * @code asio::streambuf b;
+ * asio::read_until(s, b, boost::regex("\r\n"));
+ * std::istream is(&b);
+ * std::string line;
+ * std::getline(is, line); @endcode
+ * After the @c read_until operation completes successfully, the buffer @c b
+ * contains the data which matched the regular expression:
+ * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
+ * The call to @c std::getline then extracts the data up to and including the
+ * newline (which is discarded), so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c', '\r' } @endcode
+ * The remaining data is left in the buffer @c b as follows:
+ * @code { 'd', 'e', ... } @endcode
+ * This data may be the start of a new line, to be extracted by a subsequent
+ * @c read_until operation.
+ */
+template <typename SyncReadStream, typename Allocator>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
+
+/// Read data into a streambuf until some part of the data it contains matches
+/// a regular expression.
+/**
+ * This function is used to read data into the specified streambuf until the
+ * streambuf's get area contains some data that matches a regular expression.
+ * The call will block until one of the following conditions is true:
+ *
+ * @li A substring of the streambuf's get area matches the regular expression.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the streambuf's get area already contains data that
+ * matches the regular expression, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param expr The regular expression.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the substring that matches the regular expression. Returns 0 if an error
+ * occurred.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond that which matched the regular expression. An
+ * application will typically leave that data in the streambuf for a subsequent
+ * read_until operation to examine.
+ */
+template <typename SyncReadStream, typename Allocator>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    asio::error_code& ec);
+
+#endif // defined(ASIO_HAS_BOOST_REGEX)
+       // || defined(GENERATING_DOCUMENTATION)
+
+/// Read data into a streambuf until a function object indicates a match.
+/**
+ * This function is used to read data into the specified streambuf until a
+ * user-defined match condition function object, when applied to the data
+ * contained in the streambuf, indicates a successful match. The call will
+ * block until one of the following conditions is true:
+ *
+ * @li The match condition function object returns a std::pair where the second
+ * element evaluates to true.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the match condition function object already indicates
+ * a match, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param match_condition The function object to be called to determine whether
+ * a match exists. The signature of the function object must be:
+ * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
+ * @endcode
+ * where @c iterator represents the type:
+ * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
+ * @endcode
+ * The iterator parameters @c begin and @c end define the range of bytes to be
+ * scanned to determine whether there is a match. The @c first member of the
+ * return value is an iterator marking one-past-the-end of the bytes that have
+ * been consumed by the match function. This iterator is used to calculate the
+ * @c begin parameter for any subsequent invocation of the match condition. The
+ * @c second member of the return value is true if a match has been found, false
+ * otherwise.
+ *
+ * @returns The number of bytes in the streambuf's get area that have been fully
+ * consumed by the match function.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond that which matched the function object. An application
+ * will typically leave that data in the streambuf for a subsequent read_until
+ * operation to examine.
+ *
+ * @note The default implementation of the @c is_match_condition type trait
+ * evaluates to true for function pointers and function objects with a
+ * @c result_type typedef. It must be specialised for other user-defined
+ * function objects.
+ *
+ * @par Examples
+ * To read data into a streambuf until whitespace is encountered:
+ * @code typedef asio::buffers_iterator<
+ *     asio::streambuf::const_buffers_type> iterator;
+ *
+ * std::pair<iterator, bool>
+ * match_whitespace(iterator begin, iterator end)
+ * {
+ *   iterator i = begin;
+ *   while (i != end)
+ *     if (std::isspace(*i++))
+ *       return std::make_pair(i, true);
+ *   return std::make_pair(i, false);
+ * }
+ * ...
+ * asio::streambuf b;
+ * asio::read_until(s, b, match_whitespace);
+ * @endcode
+ *
+ * To read data into a streambuf until a matching character is found:
+ * @code class match_char
+ * {
+ * public:
+ *   explicit match_char(char c) : c_(c) {}
+ *
+ *   template <typename Iterator>
+ *   std::pair<Iterator, bool> operator()(
+ *       Iterator begin, Iterator end) const
+ *   {
+ *     Iterator i = begin;
+ *     while (i != end)
+ *       if (c_ == *i++)
+ *         return std::make_pair(i, true);
+ *     return std::make_pair(i, false);
+ *   }
+ *
+ * private:
+ *   char c_;
+ * };
+ *
+ * namespace asio {
+ *   template <> struct is_match_condition<match_char>
+ *     : public boost::true_type {};
+ * } // namespace asio
+ * ...
+ * asio::streambuf b;
+ * asio::read_until(s, b, match_char('a'));
+ * @endcode
+ */
+template <typename SyncReadStream, typename Allocator, typename MatchCondition>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
+
+/// Read data into a streambuf until a function object indicates a match.
+/**
+ * This function is used to read data into the specified streambuf until a
+ * user-defined match condition function object, when applied to the data
+ * contained in the streambuf, indicates a successful match. The call will
+ * block until one of the following conditions is true:
+ *
+ * @li The match condition function object returns a std::pair where the second
+ * element evaluates to true.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * read_some function. If the match condition function object already indicates
+ * a match, the function returns immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the SyncReadStream concept.
+ *
+ * @param b A streambuf object into which the data will be read.
+ *
+ * @param match_condition The function object to be called to determine whether
+ * a match exists. The signature of the function object must be:
+ * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
+ * @endcode
+ * where @c iterator represents the type:
+ * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
+ * @endcode
+ * The iterator parameters @c begin and @c end define the range of bytes to be
+ * scanned to determine whether there is a match. The @c first member of the
+ * return value is an iterator marking one-past-the-end of the bytes that have
+ * been consumed by the match function. This iterator is used to calculate the
+ * @c begin parameter for any subsequent invocation of the match condition. The
+ * @c second member of the return value is true if a match has been found, false
+ * otherwise.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes in the streambuf's get area that have been fully
+ * consumed by the match function. Returns 0 if an error occurred.
+ *
+ * @note After a successful read_until operation, the streambuf may contain
+ * additional data beyond that which matched the function object. An application
+ * will typically leave that data in the streambuf for a subsequent read_until
+ * operation to examine.
+ *
+ * @note The default implementation of the @c is_match_condition type trait
+ * evaluates to true for function pointers and function objects with a
+ * @c result_type typedef. It must be specialised for other user-defined
+ * function objects.
+ */
+template <typename SyncReadStream, typename Allocator, typename MatchCondition>
+std::size_t read_until(SyncReadStream& s,
+    asio::basic_streambuf<Allocator>& b,
+    MatchCondition match_condition, asio::error_code& ec,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
+
+#endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
+/*@}*/
+/**
+ * @defgroup async_read_until asio::async_read_until
+ *
+ * @brief Start an asynchronous operation to read data into a dynamic buffer
+ * sequence, or into a streambuf, until it contains a delimiter, matches a
+ * regular expression, or a function object indicates a match.
+ */
+/*@{*/
+
+/// Start an asynchronous operation to read data into a dynamic buffer sequence
+/// until it contains a specified delimiter.
+/**
+ * This function is used to asynchronously read data into the specified dynamic
+ * buffer sequence until the dynamic buffer sequence's get area contains the
+ * specified delimiter. The function call always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions
+ * is true:
+ *
+ * @li The get area of the dynamic buffer sequence contains the specified
+ * delimiter.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * async_read_some function, and is known as a <em>composed operation</em>. If
+ * the dynamic buffer sequence's get area already contains the delimiter, this
+ * asynchronous operation completes immediately. The program must ensure that
+ * the stream performs no other read operations (such as async_read,
+ * async_read_until, the stream's async_read_some function, or any other
+ * composed operations that perform reads) until this operation completes.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the AsyncReadStream concept.
+ *
+ * @param buffers The dynamic buffer sequence into which the data will be read.
+ * 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 delim The delimiter character.
+ *
+ * @param handler The handler to be called when the read 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.
+ *   const asio::error_code& error,
+ *
+ *   // The number of bytes in the dynamic buffer sequence's
+ *   // get area up to and including the delimiter.
+ *   // 0 if an error occurred.
+ *   std::size_t bytes_transferred
+ * ); @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
+ * asio::io_context::post().
+ *
+ * @note After a successful async_read_until operation, the dynamic buffer
+ * sequence may contain additional data beyond the delimiter. An application
+ * will typically leave that data in the dynamic buffer sequence for a
+ * subsequent async_read_until operation to examine.
+ *
+ * @par Example
+ * To asynchronously read data into a @c std::string until a newline is
+ * encountered:
+ * @code std::string data;
+ * ...
+ * void handler(const asio::error_code& e, std::size_t size)
+ * {
+ *   if (!e)
+ *   {
+ *     std::string line = data.substr(0, n);
+ *     data.erase(0, n);
+ *     ...
+ *   }
+ * }
+ * ...
+ * asio::async_read_until(s, data, '\n', handler); @endcode
+ * After the @c async_read_until operation completes successfully, the buffer
+ * @c data contains the delimiter:
+ * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
+ * The call to @c substr then extracts the data up to and including the
+ * delimiter, so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c', '\n' } @endcode
+ * After the call to @c erase, the remaining data is left in the buffer @c data
+ * as follows:
+ * @code { 'd', 'e', ... } @endcode
+ * This data may be the start of a new line, to be extracted by a subsequent
+ * @c async_read_until operation.
+ */
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
+ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    char delim, ASIO_MOVE_ARG(ReadHandler) handler);
+
+/// Start an asynchronous operation to read data into a dynamic buffer sequence
+/// until it contains a specified delimiter.
 /**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains some data that matches a regular expression.
- * The call will block until one of the following conditions is true:
+ * This function is used to asynchronously read data into the specified dynamic
+ * buffer sequence until the dynamic buffer sequence's get area contains the
+ * specified delimiter. The function call always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions
+ * is true:
  *
- * @li A substring of the streambuf's get area matches the regular expression.
+ * @li The get area of the dynamic buffer sequence contains the specified
+ * delimiter.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains data that
- * matches the regular expression, the function returns immediately.
+ * async_read_some function, and is known as a <em>composed operation</em>. If
+ * the dynamic buffer sequence's get area already contains the delimiter, this
+ * asynchronous operation completes immediately. The program must ensure that
+ * the stream performs no other read operations (such as async_read,
+ * async_read_until, the stream's async_read_some function, or any other
+ * composed operations that perform reads) until this operation completes.
  *
  * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
+ * the AsyncReadStream concept.
  *
- * @param b A streambuf object into which the data will be read.
+ * @param buffers The dynamic buffer sequence into which the data will be read.
+ * 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 expr The regular expression.
+ * @param delim The delimiter string.
  *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the substring that matches the regular expression.
+ * @param handler The handler to be called when the read 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.
+ *   const asio::error_code& error,
  *
- * @throws asio::system_error Thrown on failure.
+ *   // The number of bytes in the dynamic buffer sequence's
+ *   // get area up to and including the delimiter.
+ *   // 0 if an error occurred.
+ *   std::size_t bytes_transferred
+ * ); @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
+ * asio::io_context::post().
  *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the regular expression. An
- * application will typically leave that data in the streambuf for a subsequent
- * read_until operation to examine.
+ * @note After a successful async_read_until operation, the dynamic buffer
+ * sequence may contain additional data beyond the delimiter. An application
+ * will typically leave that data in the dynamic buffer sequence for a
+ * subsequent async_read_until operation to examine.
  *
  * @par Example
- * To read data into a streambuf until a CR-LF sequence is encountered:
- * @code asio::streambuf b;
- * asio::read_until(s, b, boost::regex("\r\n"));
- * std::istream is(&b);
- * std::string line;
- * std::getline(is, line); @endcode
- * After the @c read_until operation completes successfully, the buffer @c b
- * contains the data which matched the regular expression:
+ * To asynchronously read data into a @c std::string until a CR-LF sequence is
+ * encountered:
+ * @code std::string data;
+ * ...
+ * void handler(const asio::error_code& e, std::size_t size)
+ * {
+ *   if (!e)
+ *   {
+ *     std::string line = data.substr(0, n);
+ *     data.erase(0, n);
+ *     ...
+ *   }
+ * }
+ * ...
+ * asio::async_read_until(s, data, "\r\n", handler); @endcode
+ * After the @c async_read_until operation completes successfully, the string
+ * @c data contains the delimiter:
  * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
- * match, so that the string @c line contains:
+ * The call to @c substr then extracts the data up to and including the
+ * delimiter, so that the string @c line contains:
  * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * The remaining data is left in the buffer @c b as follows:
+ * After the call to @c erase, the remaining data is left in the string @c data
+ * as follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
+ * @c async_read_until operation.
  */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
+ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_STRING_VIEW_PARAM delim,
+    ASIO_MOVE_ARG(ReadHandler) handler);
 
-/// Read data into a streambuf until some part of the data it contains matches
-/// a regular expression.
+#if !defined(ASIO_NO_EXTENSIONS)
+#if defined(ASIO_HAS_BOOST_REGEX) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Start an asynchronous operation to read data into a dynamic buffer sequence
+/// until some part of its data matches a regular expression.
 /**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains some data that matches a regular expression.
- * The call will block until one of the following conditions is true:
+ * This function is used to asynchronously read data into the specified dynamic
+ * buffer sequence until the dynamic buffer sequence's get area contains some
+ * data that matches a regular expression. The function call always returns
+ * immediately. The asynchronous operation will continue until one of the
+ * following conditions is true:
  *
- * @li A substring of the streambuf's get area matches the regular expression.
+ * @li A substring of the dynamic buffer sequence's get area matches the regular
+ * expression.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains data that
- * matches the regular expression, the function returns immediately.
+ * async_read_some function, and is known as a <em>composed operation</em>. If
+ * the dynamic buffer sequence's get area already contains data that matches
+ * the regular expression, this asynchronous operation completes immediately.
+ * The program must ensure that the stream performs no other read operations
+ * (such as async_read, async_read_until, the stream's async_read_some
+ * function, or any other composed operations that perform reads) until this
+ * operation completes.
  *
  * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
+ * the AsyncReadStream concept.
  *
- * @param b A streambuf object into which the data will be read.
+ * @param buffers The dynamic buffer sequence into which the data will be read.
+ * 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 expr The regular expression.
  *
- * @param ec Set to indicate what error occurred, if any.
+ * @param handler The handler to be called when the read 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.
+ *   const asio::error_code& error,
  *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the substring that matches the regular expression. Returns 0 if an error
- * occurred.
+ *   // The number of bytes in the dynamic buffer
+ *   // sequence's get area up to and including the
+ *   // substring that matches the regular expression.
+ *   // 0 if an error occurred.
+ *   std::size_t bytes_transferred
+ * ); @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
+ * asio::io_context::post().
  *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the regular expression. An
- * application will typically leave that data in the streambuf for a subsequent
- * read_until operation to examine.
+ * @note After a successful async_read_until operation, the dynamic buffer
+ * sequence may contain additional data beyond that which matched the regular
+ * expression. An application will typically leave that data in the dynamic
+ * buffer sequence for a subsequent async_read_until operation to examine.
+ *
+ * @par Example
+ * To asynchronously read data into a @c std::string until a CR-LF sequence is
+ * encountered:
+ * @code std::string data;
+ * ...
+ * void handler(const asio::error_code& e, std::size_t size)
+ * {
+ *   if (!e)
+ *   {
+ *     std::string line = data.substr(0, n);
+ *     data.erase(0, n);
+ *     ...
+ *   }
+ * }
+ * ...
+ * asio::async_read_until(s, data,
+ *     boost::regex("\r\n"), handler); @endcode
+ * After the @c async_read_until operation completes successfully, the string
+ * @c data contains the data which matched the regular expression:
+ * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
+ * The call to @c substr then extracts the data up to and including the match,
+ * so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
+ * After the call to @c erase, the remaining data is left in the string @c data
+ * as follows:
+ * @code { 'd', 'e', ... } @endcode
+ * This data may be the start of a new line, to be extracted by a subsequent
+ * @c async_read_until operation.
  */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    asio::error_code& ec);
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
+ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr,
+    ASIO_MOVE_ARG(ReadHandler) handler);
 
 #endif // defined(ASIO_HAS_BOOST_REGEX)
        // || defined(GENERATING_DOCUMENTATION)
 
-/// Read data into a streambuf until a function object indicates a match.
+/// Start an asynchronous operation to read data into a dynamic buffer sequence
+/// until a function object indicates a match.
 /**
- * This function is used to read data into the specified streambuf until a
- * user-defined match condition function object, when applied to the data
- * contained in the streambuf, indicates a successful match. The call will
- * block until one of the following conditions is true:
+ * This function is used to asynchronously read data into the specified dynamic
+ * buffer sequence until a user-defined match condition function object, when
+ * applied to the data contained in the dynamic buffer sequence, indicates a
+ * successful match. The function call always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions
+ * is true:
  *
  * @li The match condition function object returns a std::pair where the second
  * element evaluates to true.
@@ -356,20 +1289,27 @@ std::size_t read_until(SyncReadStream& s,
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
+ * async_read_some function, and is known as a <em>composed operation</em>. If
+ * the match condition function object already indicates a match, this
+ * asynchronous operation completes immediately. The program must ensure that
+ * the stream performs no other read operations (such as async_read,
+ * async_read_until, the stream's async_read_some function, or any other
+ * composed operations that perform reads) until this operation completes.
  *
  * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
+ * the AsyncReadStream concept.
  *
- * @param b A streambuf object into which the data will be read.
+ * @param buffers The dynamic buffer sequence into which the data will be read.
+ * 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 match_condition The function object to be called to determine whether
  * a match exists. The signature of the function object must be:
  * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
  * @endcode
  * where @c iterator represents the type:
- * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
+ * @code buffers_iterator<typename DynamicBuffer::const_buffers_type>
  * @endcode
  * The iterator parameters @c begin and @c end define the range of bytes to be
  * scanned to determine whether there is a match. The @c first member of the
@@ -379,14 +1319,27 @@ std::size_t read_until(SyncReadStream& s,
  * @c second member of the return value is true if a match has been found, false
  * otherwise.
  *
- * @returns The number of bytes in the streambuf's get area that have been fully
- * consumed by the match function.
+ * @param handler The handler to be called when the read 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.
+ *   const asio::error_code& error,
  *
- * @throws asio::system_error Thrown on failure.
+ *   // The number of bytes in the dynamic buffer sequence's
+ *   // get area that have been fully consumed by the match
+ *   // function. O if an error occurred.
+ *   std::size_t bytes_transferred
+ * ); @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
+ * asio::io_context::post().
  *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the function object. An application
- * will typically leave that data in the streambuf for a subsequent
+ * @note After a successful async_read_until operation, the dynamic buffer
+ * sequence may contain additional data beyond that which matched the function
+ * object. An application will typically leave that data in the dynamic buffer
+ * sequence for a subsequent async_read_until operation to examine.
  *
  * @note The default implementation of the @c is_match_condition type trait
  * evaluates to true for function pointers and function objects with a
@@ -394,9 +1347,10 @@ std::size_t read_until(SyncReadStream& s,
  * function objects.
  *
  * @par Examples
- * To read data into a streambuf until whitespace is encountered:
+ * To asynchronously read data into a @c std::string until whitespace is
+ * encountered:
  * @code typedef asio::buffers_iterator<
- *     asio::streambuf::const_buffers_type> iterator;
+ *     asio::const_buffers_1> iterator;
  *
  * std::pair<iterator, bool>
  * match_whitespace(iterator begin, iterator end)
@@ -408,11 +1362,14 @@ std::size_t read_until(SyncReadStream& s,
  *   return std::make_pair(i, false);
  * }
  * ...
- * asio::streambuf b;
- * asio::read_until(s, b, match_whitespace);
+ * void handler(const asio::error_code& e, std::size_t size);
+ * ...
+ * std::string data;
+ * asio::async_read_until(s, data, match_whitespace, handler);
  * @endcode
  *
- * To read data into a streambuf until a matching character is found:
+ * To asynchronously read data into a @c std::string until a matching character
+ * is found:
  * @code class match_char
  * {
  * public:
@@ -438,80 +1395,22 @@ std::size_t read_until(SyncReadStream& s,
  *     : public boost::true_type {};
  * } // namespace asio
  * ...
- * asio::streambuf b;
- * asio::read_until(s, b, match_char('a'));
- * @endcode
- */
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
-    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
-
-/// Read data into a streambuf until a function object indicates a match.
-/**
- * This function is used to read data into the specified streambuf until a
- * user-defined match condition function object, when applied to the data
- * contained in the streambuf, indicates a successful match. The call will
- * block until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
+ * void handler(const asio::error_code& e, std::size_t size);
+ * ...
+ * std::string data;
+ * asio::async_read_until(s, data, match_char('a'), handler);
  * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the streambuf's get area that have been fully
- * consumed by the match function. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the function object. An application
- * will typically leave that data in the streambuf for a subsequent
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
  */
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, asio::error_code& ec,
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename MatchCondition, typename ReadHandler>
+ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (asio::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    MatchCondition match_condition, ASIO_MOVE_ARG(ReadHandler) handler,
     typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
 
-/*@}*/
-/**
- * @defgroup async_read_until asio::async_read_until
- *
- * @brief Start an asynchronous operation to read data into a streambuf until it
- * contains a delimiter, matches a regular expression, or a function object
- * indicates a match.
- */
-/*@{*/
+#if !defined(ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to read data into a streambuf until it
 /// contains a specified delimiter.
@@ -557,7 +1456,7 @@ std::size_t read_until(SyncReadStream& s,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond the delimiter. An application will typically
@@ -584,8 +1483,8 @@ std::size_t read_until(SyncReadStream& s,
  * @c b contains the delimiter:
  * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
  * The call to @c std::getline then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\n' } @endcode
+ * newline (which is discarded), so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c' } @endcode
  * The remaining data is left in the buffer @c b as follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
@@ -642,7 +1541,7 @@ async_read_until(AsyncReadStream& s,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond the delimiter. An application will typically
@@ -669,8 +1568,8 @@ async_read_until(AsyncReadStream& s,
  * @c b contains the delimiter:
  * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
  * The call to @c std::getline then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
+ * newline (which is discarded), so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c', '\r' } @endcode
  * The remaining data is left in the buffer @c b as follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
@@ -680,7 +1579,8 @@ template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (asio::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, const std::string& delim,
+    asio::basic_streambuf<Allocator>& b,
+    ASIO_STRING_VIEW_PARAM delim,
     ASIO_MOVE_ARG(ReadHandler) handler);
 
 #if defined(ASIO_HAS_BOOST_REGEX) \
@@ -733,7 +1633,7 @@ async_read_until(AsyncReadStream& s,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond that which matched the regular expression. An
@@ -761,8 +1661,8 @@ async_read_until(AsyncReadStream& s,
  * @c b contains the data which matched the regular expression:
  * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
  * The call to @c std::getline then extracts the data up to and including the
- * match, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
+ * newline (which is discarded), so that the string @c line contains:
+ * @code { 'a', 'b', ..., 'c', '\r' } @endcode
  * The remaining data is left in the buffer @c b as follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
@@ -835,7 +1735,7 @@ async_read_until(AsyncReadStream& s,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond that which matched the function object. An
@@ -910,6 +1810,9 @@ async_read_until(AsyncReadStream& s,
     MatchCondition match_condition, ASIO_MOVE_ARG(ReadHandler) handler,
     typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
 
+#endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 /*@}*/
 
 } // namespace asio
@@ -918,6 +1821,4 @@ async_read_until(AsyncReadStream& s,
 
 #include "asio/impl/read_until.hpp"
 
-#endif // !defined(ASIO_NO_IOSTREAM)
-
 #endif // ASIO_READ_UNTIL_HPP
diff --git a/extern/include/asio/seq_packet_socket_service.hpp b/extern/include/asio/seq_packet_socket_service.hpp
index e25ee5c3..7e6824d4 100644
--- a/extern/include/asio/seq_packet_socket_service.hpp
+++ b/extern/include/asio/seq_packet_socket_service.hpp
@@ -2,7 +2,7 @@
 // seq_packet_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include <cstddef>
 #include "asio/async_result.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/null_socket_service.hpp"
@@ -38,7 +41,7 @@ namespace asio {
 template <typename Protocol>
 class seq_packet_socket_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<
       seq_packet_socket_service<Protocol> >
@@ -47,7 +50,7 @@ class seq_packet_socket_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The protocol type.
@@ -74,13 +77,6 @@ class seq_packet_socket_service
   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;
@@ -89,11 +85,11 @@ class seq_packet_socket_service
 #endif
 
   /// Construct a new sequenced packet socket service for the specified
-  /// io_service.
-  explicit seq_packet_socket_service(asio::io_service& io_service)
+  /// io_context.
+  explicit seq_packet_socket_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        seq_packet_socket_service<Protocol> >(io_service),
-      service_impl_(io_service)
+        seq_packet_socket_service<Protocol> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -119,17 +115,21 @@ class seq_packet_socket_service
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
 
+  // All socket services have access to each other's implementations.
+  template <typename Protocol1> friend class seq_packet_socket_service;
+
   /// Move-construct a new sequenced packet socket implementation from another
   /// protocol type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      seq_packet_socket_service<Protocol1>& other_service,
       typename seq_packet_socket_service<
         Protocol1>::implementation_type& other_impl,
       typename enable_if<is_convertible<
         Protocol1, Protocol>::value>::type* = 0)
   {
     service_impl_.template converting_move_construct<Protocol1>(
-        impl, other_impl);
+        impl, other_service.service_impl_, other_impl);
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
@@ -140,22 +140,23 @@ class seq_packet_socket_service
   }
 
   /// Open a sequenced packet socket.
-  asio::error_code open(implementation_type& impl,
+  ASIO_SYNC_OP_VOID open(implementation_type& impl,
       const protocol_type& protocol, asio::error_code& ec)
   {
     if (protocol.type() == ASIO_OS_DEF(SOCK_SEQPACKET))
       service_impl_.open(impl, protocol, ec);
     else
       ec = asio::error::invalid_argument;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native socket to a sequenced packet socket.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const protocol_type& protocol, const native_handle_type& native_socket,
       asio::error_code& ec)
   {
-    return service_impl_.assign(impl, protocol, native_socket, ec);
+    service_impl_.assign(impl, protocol, native_socket, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is open.
@@ -165,16 +166,18 @@ class seq_packet_socket_service
   }
 
   /// Close a sequenced packet socket implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
+  /// Release ownership of the underlying socket.
+  native_handle_type release(implementation_type& impl,
+      asio::error_code& ec)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.release(impl, ec);
   }
 
   /// Get the native socket implementation.
@@ -184,10 +187,11 @@ class seq_packet_socket_service
   }
 
   /// Cancel all asynchronous operations associated with the socket.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
@@ -205,17 +209,19 @@ class seq_packet_socket_service
   }
 
   /// Bind the sequenced packet socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
+  ASIO_SYNC_OP_VOID bind(implementation_type& impl,
       const endpoint_type& endpoint, asio::error_code& ec)
   {
-    return service_impl_.bind(impl, endpoint, ec);
+    service_impl_.bind(impl, endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Connect the sequenced packet socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
+  ASIO_SYNC_OP_VOID connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, asio::error_code& ec)
   {
-    return service_impl_.connect(impl, peer_endpoint, ec);
+    service_impl_.connect(impl, peer_endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous connect.
@@ -226,37 +232,39 @@ class seq_packet_socket_service
       const endpoint_type& peer_endpoint,
       ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    detail::async_result_init<
-      ConnectHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(ConnectHandler)(handler));
+    async_completion<ConnectHandler,
+      void (asio::error_code)> init(handler);
 
-    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+    service_impl_.async_connect(impl, peer_endpoint, init.completion_handler);
 
     return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
-  asio::error_code set_option(implementation_type& impl,
+  ASIO_SYNC_OP_VOID set_option(implementation_type& impl,
       const SettableSocketOption& option, asio::error_code& ec)
   {
-    return service_impl_.set_option(impl, option, ec);
+    service_impl_.set_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
-  asio::error_code get_option(const implementation_type& impl,
+  ASIO_SYNC_OP_VOID get_option(const implementation_type& impl,
       GettableSocketOption& option, asio::error_code& ec) const
   {
-    return service_impl_.get_option(impl, option, ec);
+    service_impl_.get_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
-  asio::error_code io_control(implementation_type& impl,
+  ASIO_SYNC_OP_VOID io_control(implementation_type& impl,
       IoControlCommand& command, asio::error_code& ec)
   {
-    return service_impl_.io_control(impl, command, ec);
+    service_impl_.io_control(impl, command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the socket.
@@ -266,10 +274,11 @@ class seq_packet_socket_service
   }
 
   /// Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.non_blocking(impl, mode, ec);
+    service_impl_.non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native socket implementation.
@@ -279,10 +288,11 @@ class seq_packet_socket_service
   }
 
   /// Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID native_non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.native_non_blocking(impl, mode, ec);
+    service_impl_.native_non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the local endpoint.
@@ -300,10 +310,36 @@ class seq_packet_socket_service
   }
 
   /// Disable sends or receives on the socket.
-  asio::error_code shutdown(implementation_type& impl,
+  ASIO_SYNC_OP_VOID shutdown(implementation_type& impl,
       socket_base::shutdown_type what, asio::error_code& ec)
   {
-    return service_impl_.shutdown(impl, what, ec);
+    service_impl_.shutdown(impl, what, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the socket to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  ASIO_SYNC_OP_VOID wait(implementation_type& impl,
+      socket_base::wait_type w, asio::error_code& ec)
+  {
+    service_impl_.wait(impl, w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the socket to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(implementation_type& impl, socket_base::wait_type w,
+      ASIO_MOVE_ARG(WaitHandler) handler)
+  {
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    service_impl_.async_wait(impl, w, init.completion_handler);
+
+    return init.result.get();
   }
 
   /// Send the given data to the peer.
@@ -324,11 +360,10 @@ class seq_packet_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_send(impl, buffers, flags, init.handler);
+    service_impl_.async_send(impl, buffers, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -352,21 +387,20 @@ class seq_packet_socket_service
       socket_base::message_flags& out_flags,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     service_impl_.async_receive_with_flags(impl,
-        buffers, in_flags, out_flags, init.handler);
+        buffers, in_flags, out_flags, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -377,4 +411,6 @@ class seq_packet_socket_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_SEQ_PACKET_SOCKET_SERVICE_HPP
diff --git a/extern/include/asio/serial_port.hpp b/extern/include/asio/serial_port.hpp
index f5ac715c..27bb63ef 100644
--- a/extern/include/asio/serial_port.hpp
+++ b/extern/include/asio/serial_port.hpp
@@ -2,7 +2,7 @@
 // serial_port.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -21,15 +21,748 @@
 #if defined(ASIO_HAS_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
-#include "asio/basic_serial_port.hpp"
+#include <string>
+#include "asio/async_result.hpp"
+#include "asio/basic_io_object.hpp"
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+#include "asio/io_context.hpp"
+#include "asio/serial_port_base.hpp"
+
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/basic_serial_port.hpp"
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+# if defined(ASIO_HAS_IOCP)
+#  include "asio/detail/win_iocp_serial_port_service.hpp"
+#  define ASIO_SVC_T detail::win_iocp_serial_port_service
+# else
+#  include "asio/detail/reactive_serial_port_service.hpp"
+#  define ASIO_SVC_T detail::reactive_serial_port_service
+# endif
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+#include "asio/detail/push_options.hpp"
 
 namespace asio {
 
-/// Typedef for the typical usage of a serial port.
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+// Typedef for the typical usage of a serial port.
 typedef basic_serial_port<> serial_port;
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+/// Provides serial port functionality.
+/**
+ * The serial_port class provides a wrapper over serial port functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class serial_port
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>,
+    public serial_port_base
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
+  /// The native representation of a serial port.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef ASIO_SVC_T::native_handle_type native_handle_type;
+#endif
+
+  /// A basic_serial_port is always the lowest layer.
+  typedef serial_port lowest_layer_type;
+
+  /// Construct a serial_port without opening it.
+  /**
+   * This constructor creates a serial port without opening it.
+   *
+   * @param io_context The io_context object that the serial port will use to
+   * dispatch handlers for any asynchronous operations performed on the port.
+   */
+  explicit serial_port(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+  }
+
+  /// Construct and open a serial_port.
+  /**
+   * This constructor creates and opens a serial port for the specified device
+   * name.
+   *
+   * @param io_context The io_context object that the serial port will use to
+   * dispatch handlers for any asynchronous operations performed on the port.
+   *
+   * @param device The platform-specific device name for this serial
+   * port.
+   */
+  explicit serial_port(asio::io_context& io_context,
+      const char* device)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().open(this->get_implementation(), device, ec);
+    asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a serial_port.
+  /**
+   * This constructor creates and opens a serial port for the specified device
+   * name.
+   *
+   * @param io_context The io_context object that the serial port will use to
+   * dispatch handlers for any asynchronous operations performed on the port.
+   *
+   * @param device The platform-specific device name for this serial
+   * port.
+   */
+  explicit serial_port(asio::io_context& io_context,
+      const std::string& device)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().open(this->get_implementation(), device, ec);
+    asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a serial_port on an existing native serial port.
+  /**
+   * This constructor creates a serial port object to hold an existing native
+   * serial port.
+   *
+   * @param io_context The io_context object that the serial port will use to
+   * dispatch handlers for any asynchronous operations performed on the port.
+   *
+   * @param native_serial_port A native serial port.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  serial_port(asio::io_context& io_context,
+      const native_handle_type& native_serial_port)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(),
+        native_serial_port, ec);
+    asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a serial_port from another.
+  /**
+   * This constructor moves a serial port from one object to another.
+   *
+   * @param other The other 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 serial_port(io_context&) constructor.
+   */
+  serial_port(serial_port&& other)
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
+  {
+  }
+
+  /// Move-assign a serial_port from another.
+  /**
+   * This assignment operator moves a serial port from one object to another.
+   *
+   * @param other The other 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 serial_port(io_context&) constructor.
+   */
+  serial_port& operator=(serial_port&& other)
+  {
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the serial port.
+  /**
+   * This function destroys the serial port, cancelling any outstanding
+   * asynchronous wait operations associated with the serial port as if by
+   * calling @c cancel.
+   */
+  ~serial_port()
+  {
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since a serial_port cannot contain any further layers, it simply
+   * returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since a serial_port cannot contain any further layers, it simply
+   * returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Open the serial port using the specified device name.
+  /**
+   * This function opens the serial port for the specified device name.
+   *
+   * @param device The platform-specific device name.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void open(const std::string& device)
+  {
+    asio::error_code ec;
+    this->get_service().open(this->get_implementation(), device, ec);
+    asio::detail::throw_error(ec, "open");
+  }
+
+  /// Open the serial port using the specified device name.
+  /**
+   * This function opens the serial port using the given platform-specific
+   * device name.
+   *
+   * @param device The platform-specific device name.
+   *
+   * @param ec Set the indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID open(const std::string& device,
+      asio::error_code& ec)
+  {
+    this->get_service().open(this->get_implementation(), device, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Assign an existing native serial port to the serial port.
+  /*
+   * This function opens the serial port to hold an existing native serial port.
+   *
+   * @param native_serial_port A native serial port.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_serial_port)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(),
+        native_serial_port, ec);
+    asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native serial port to the serial port.
+  /*
+   * This function opens the serial port to hold an existing native serial port.
+   *
+   * @param native_serial_port A native serial port.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_serial_port,
+      asio::error_code& ec)
+  {
+    this->get_service().assign(this->get_implementation(),
+        native_serial_port, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the serial port is open.
+  bool is_open() const
+  {
+    return this->get_service().is_open(this->get_implementation());
+  }
+
+  /// Close the serial port.
+  /**
+   * This function is used to close the serial port. Any asynchronous read or
+   * write operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void close()
+  {
+    asio::error_code ec;
+    this->get_service().close(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the serial port.
+  /**
+   * This function is used to close the serial port. Any asynchronous read or
+   * write operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
+  {
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// 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.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    asio::error_code ec;
+    this->get_service().cancel(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the serial port.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
+  {
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Send a break sequence to the serial port.
+  /**
+   * This function causes a break sequence of platform-specific duration to be
+   * sent out the serial port.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void send_break()
+  {
+    asio::error_code ec;
+    this->get_service().send_break(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "send_break");
+  }
+
+  /// Send a break sequence to the serial port.
+  /**
+   * This function causes a break sequence of platform-specific duration to be
+   * sent out the serial port.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID send_break(asio::error_code& ec)
+  {
+    this->get_service().send_break(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Set an option on the serial port.
+  /**
+   * This function is used to set an option on the serial port.
+   *
+   * @param option The option value to be set on the serial port.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @sa SettableSerialPortOption @n
+   * asio::serial_port_base::baud_rate @n
+   * asio::serial_port_base::flow_control @n
+   * asio::serial_port_base::parity @n
+   * asio::serial_port_base::stop_bits @n
+   * asio::serial_port_base::character_size
+   */
+  template <typename SettableSerialPortOption>
+  void set_option(const SettableSerialPortOption& option)
+  {
+    asio::error_code ec;
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    asio::detail::throw_error(ec, "set_option");
+  }
+
+  /// Set an option on the serial port.
+  /**
+   * This function is used to set an option on the serial port.
+   *
+   * @param option The option value to be set on the serial port.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @sa SettableSerialPortOption @n
+   * asio::serial_port_base::baud_rate @n
+   * asio::serial_port_base::flow_control @n
+   * asio::serial_port_base::parity @n
+   * asio::serial_port_base::stop_bits @n
+   * asio::serial_port_base::character_size
+   */
+  template <typename SettableSerialPortOption>
+  ASIO_SYNC_OP_VOID set_option(const SettableSerialPortOption& option,
+      asio::error_code& ec)
+  {
+    this->get_service().set_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Get an option from the serial port.
+  /**
+   * This function is used to get the current value of an option on the serial
+   * port.
+   *
+   * @param option The option value to be obtained from the serial port.
+   *
+   * @throws asio::system_error Thrown on failure.
+   *
+   * @sa GettableSerialPortOption @n
+   * asio::serial_port_base::baud_rate @n
+   * asio::serial_port_base::flow_control @n
+   * asio::serial_port_base::parity @n
+   * asio::serial_port_base::stop_bits @n
+   * asio::serial_port_base::character_size
+   */
+  template <typename GettableSerialPortOption>
+  void get_option(GettableSerialPortOption& option)
+  {
+    asio::error_code ec;
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    asio::detail::throw_error(ec, "get_option");
+  }
+
+  /// Get an option from the serial port.
+  /**
+   * This function is used to get the current value of an option on the serial
+   * port.
+   *
+   * @param option The option value to be obtained from the serial port.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @sa GettableSerialPortOption @n
+   * asio::serial_port_base::baud_rate @n
+   * asio::serial_port_base::flow_control @n
+   * asio::serial_port_base::parity @n
+   * asio::serial_port_base::stop_bits @n
+   * asio::serial_port_base::character_size
+   */
+  template <typename GettableSerialPortOption>
+  ASIO_SYNC_OP_VOID get_option(GettableSerialPortOption& option,
+      asio::error_code& ec)
+  {
+    this->get_service().get_option(this->get_implementation(), option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Write some data to the serial port.
+  /**
+   * This function is used to write data to the serial port. The function call
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the serial port.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The write_some 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.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * serial_port.write_some(asio::buffer(data, size));
+   * @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.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+    asio::detail::throw_error(ec, "write_some");
+    return s;
+  }
+
+  /// Write some data to the serial port.
+  /**
+   * This function is used to write data to the serial port. The function call
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the serial port.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some 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 write_some(const ConstBufferSequence& buffers,
+      asio::error_code& ec)
+  {
+    return this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the serial port.
+   * The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be written to the serial port.
+   * 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 handler The handler to be called when the write operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes written.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write function if you need to ensure that all
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * serial_port.async_write_some(asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename ConstBufferSequence, typename WriteHandler>
+  ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (asio::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      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.
+    ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_write_some(
+        this->get_implementation(), buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+
+  /// Read some data from the serial port.
+  /**
+   * This function is used to read data from the serial port. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The read_some operation may not read 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 read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * serial_port.read_some(asio::buffer(data, size));
+   * @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.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+    asio::detail::throw_error(ec, "read_some");
+    return s;
+  }
+
+  /// Read some data from the serial port.
+  /**
+   * This function is used to read data from the serial port. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read 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 read_some(const MutableBufferSequence& buffers,
+      asio::error_code& ec)
+  {
+    return this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the serial port.
+   * The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * 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 handler The handler to be called when the read operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes read.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read function if you need to ensure that the
+   * requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * serial_port.async_read_some(asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename MutableBufferSequence, typename ReadHandler>
+  ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (asio::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      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.
+    ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_read_some(
+        this->get_implementation(), buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+};
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 } // namespace asio
 
+#include "asio/detail/pop_options.hpp"
+
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+# undef ASIO_SVC_T
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // defined(ASIO_HAS_SERIAL_PORT)
        //   || defined(GENERATING_DOCUMENTATION)
 
diff --git a/extern/include/asio/serial_port_base.hpp b/extern/include/asio/serial_port_base.hpp
index a6d86523..feb5b9df 100644
--- a/extern/include/asio/serial_port_base.hpp
+++ b/extern/include/asio/serial_port_base.hpp
@@ -2,7 +2,7 @@
 // serial_port_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -54,10 +54,10 @@ class serial_port_base
   public:
     explicit baud_rate(unsigned int rate = 0);
     unsigned int value() const;
-    ASIO_DECL asio::error_code store(
+    ASIO_DECL ASIO_SYNC_OP_VOID store(
         ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec) const;
-    ASIO_DECL asio::error_code load(
+    ASIO_DECL ASIO_SYNC_OP_VOID load(
         const ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec);
   private:
@@ -74,10 +74,10 @@ class serial_port_base
     enum type { none, software, hardware };
     ASIO_DECL explicit flow_control(type t = none);
     type value() const;
-    ASIO_DECL asio::error_code store(
+    ASIO_DECL ASIO_SYNC_OP_VOID store(
         ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec) const;
-    ASIO_DECL asio::error_code load(
+    ASIO_DECL ASIO_SYNC_OP_VOID load(
         const ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec);
   private:
@@ -94,10 +94,10 @@ class serial_port_base
     enum type { none, odd, even };
     ASIO_DECL explicit parity(type t = none);
     type value() const;
-    ASIO_DECL asio::error_code store(
+    ASIO_DECL ASIO_SYNC_OP_VOID store(
         ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec) const;
-    ASIO_DECL asio::error_code load(
+    ASIO_DECL ASIO_SYNC_OP_VOID load(
         const ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec);
   private:
@@ -114,10 +114,10 @@ class serial_port_base
     enum type { one, onepointfive, two };
     ASIO_DECL explicit stop_bits(type t = one);
     type value() const;
-    ASIO_DECL asio::error_code store(
+    ASIO_DECL ASIO_SYNC_OP_VOID store(
         ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec) const;
-    ASIO_DECL asio::error_code load(
+    ASIO_DECL ASIO_SYNC_OP_VOID load(
         const ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec);
   private:
@@ -133,10 +133,10 @@ class serial_port_base
   public:
     ASIO_DECL explicit character_size(unsigned int t = 8);
     unsigned int value() const;
-    ASIO_DECL asio::error_code store(
+    ASIO_DECL ASIO_SYNC_OP_VOID store(
         ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec) const;
-    ASIO_DECL asio::error_code load(
+    ASIO_DECL ASIO_SYNC_OP_VOID load(
         const ASIO_OPTION_STORAGE& storage,
         asio::error_code& ec);
   private:
diff --git a/extern/include/asio/serial_port_service.hpp b/extern/include/asio/serial_port_service.hpp
index c13a2b6c..0e20d96e 100644
--- a/extern/include/asio/serial_port_service.hpp
+++ b/extern/include/asio/serial_port_service.hpp
@@ -2,7 +2,7 @@
 // serial_port_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -26,7 +28,7 @@
 #include "asio/detail/reactive_serial_port_service.hpp"
 #include "asio/detail/win_iocp_serial_port_service.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/serial_port_base.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -36,7 +38,7 @@ namespace asio {
 /// Default service implementation for a serial port.
 class serial_port_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<serial_port_service>
 #endif
@@ -44,7 +46,7 @@ class serial_port_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
 private:
@@ -63,13 +65,6 @@ class serial_port_service
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native handle type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_handle_type;
@@ -77,10 +72,10 @@ class serial_port_service
   typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new serial port service for the specified io_service.
-  explicit serial_port_service(asio::io_service& io_service)
-    : asio::detail::service_base<serial_port_service>(io_service),
-      service_impl_(io_service)
+  /// Construct a new serial port service for the specified io_context.
+  explicit serial_port_service(asio::io_context& io_context)
+    : asio::detail::service_base<serial_port_service>(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -114,17 +109,19 @@ class serial_port_service
   }
 
   /// Open a serial port.
-  asio::error_code open(implementation_type& impl,
+  ASIO_SYNC_OP_VOID open(implementation_type& impl,
       const std::string& device, asio::error_code& ec)
   {
-    return service_impl_.open(impl, device, ec);
+    service_impl_.open(impl, device, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native handle to a serial port.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const native_handle_type& handle, asio::error_code& ec)
   {
-    return service_impl_.assign(impl, handle, ec);
+    service_impl_.assign(impl, handle, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the handle is open.
@@ -134,16 +131,11 @@ class serial_port_service
   }
 
   /// Close a serial port implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native handle implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native handle implementation.
@@ -153,33 +145,37 @@ class serial_port_service
   }
 
   /// Cancel all asynchronous operations associated with the handle.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Set a serial port option.
   template <typename SettableSerialPortOption>
-  asio::error_code set_option(implementation_type& impl,
+  ASIO_SYNC_OP_VOID set_option(implementation_type& impl,
       const SettableSerialPortOption& option, asio::error_code& ec)
   {
-    return service_impl_.set_option(impl, option, ec);
+    service_impl_.set_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get a serial port option.
   template <typename GettableSerialPortOption>
-  asio::error_code get_option(const implementation_type& impl,
+  ASIO_SYNC_OP_VOID get_option(const implementation_type& impl,
       GettableSerialPortOption& option, asio::error_code& ec) const
   {
-    return service_impl_.get_option(impl, option, ec);
+    service_impl_.get_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Send a break sequence to the serial port.
-  asio::error_code send_break(implementation_type& impl,
+  ASIO_SYNC_OP_VOID send_break(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.send_break(impl, ec);
+    service_impl_.send_break(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Write the given data to the stream.
@@ -198,11 +194,10 @@ class serial_port_service
       const ConstBufferSequence& buffers,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_write_some(impl, buffers, init.handler);
+    service_impl_.async_write_some(impl, buffers, init.completion_handler);
 
     return init.result.get();
   }
@@ -223,20 +218,19 @@ class serial_port_service
       const MutableBufferSequence& buffers,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_read_some(impl, buffers, init.handler);
+    service_impl_.async_read_some(impl, buffers, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -250,4 +244,6 @@ class serial_port_service
 #endif // defined(ASIO_HAS_SERIAL_PORT)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_SERIAL_PORT_SERVICE_HPP
diff --git a/extern/include/asio/signal_set.hpp b/extern/include/asio/signal_set.hpp
index 985b6fa4..30e5c4e3 100644
--- a/extern/include/asio/signal_set.hpp
+++ b/extern/include/asio/signal_set.hpp
@@ -2,7 +2,7 @@
 // signal_set.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,12 +16,431 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/basic_signal_set.hpp"
+
+#include "asio/async_result.hpp"
+#include "asio/basic_io_object.hpp"
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+#include "asio/io_context.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/basic_signal_set.hpp"
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/detail/signal_set_service.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 namespace asio {
 
-/// Typedef for the typical usage of a signal set.
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+// Typedef for the typical usage of a signal set.
 typedef basic_signal_set<> signal_set;
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+/// Provides signal functionality.
+/**
+ * The signal_set class provides the ability to perform an asynchronous wait
+ * for one or more signals to occur.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Example
+ * Performing an asynchronous wait:
+ * @code
+ * void handler(
+ *     const asio::error_code& error,
+ *     int signal_number)
+ * {
+ *   if (!error)
+ *   {
+ *     // A signal occurred.
+ *   }
+ * }
+ *
+ * ...
+ *
+ * // Construct a signal set registered for process termination.
+ * asio::signal_set signals(io_context, 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.
+ */
+class signal_set
+  : ASIO_SVC_ACCESS basic_io_object<detail::signal_set_service>
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
+  /// Construct a signal set without adding any signals.
+  /**
+   * This constructor creates a signal set without registering for any signals.
+   *
+   * @param io_context The io_context object that the signal set will use to
+   * dispatch handlers for any asynchronous operations performed on the set.
+   */
+  explicit signal_set(asio::io_context& io_context)
+    : basic_io_object<detail::signal_set_service>(io_context)
+  {
+  }
+
+  /// Construct a signal set and add one signal.
+  /**
+   * This constructor creates a signal set and registers for one signal.
+   *
+   * @param io_context The io_context 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 asio::signal_set signals(io_context);
+   * signals.add(signal_number_1); @endcode
+   */
+  signal_set(asio::io_context& io_context, int signal_number_1)
+    : basic_io_object<detail::signal_set_service>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().add(this->get_implementation(), signal_number_1, ec);
+    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_context The io_context 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 asio::signal_set signals(io_context);
+   * signals.add(signal_number_1);
+   * signals.add(signal_number_2); @endcode
+   */
+  signal_set(asio::io_context& io_context, int signal_number_1,
+      int signal_number_2)
+    : basic_io_object<detail::signal_set_service>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().add(this->get_implementation(), signal_number_1, ec);
+    asio::detail::throw_error(ec, "add");
+    this->get_service().add(this->get_implementation(), signal_number_2, ec);
+    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_context The io_context 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 asio::signal_set signals(io_context);
+   * signals.add(signal_number_1);
+   * signals.add(signal_number_2);
+   * signals.add(signal_number_3); @endcode
+   */
+  signal_set(asio::io_context& io_context, int signal_number_1,
+      int signal_number_2, int signal_number_3)
+    : basic_io_object<detail::signal_set_service>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().add(this->get_implementation(), signal_number_1, ec);
+    asio::detail::throw_error(ec, "add");
+    this->get_service().add(this->get_implementation(), signal_number_2, ec);
+    asio::detail::throw_error(ec, "add");
+    this->get_service().add(this->get_implementation(), signal_number_3, ec);
+    asio::detail::throw_error(ec, "add");
+  }
+
+  /// Destroys the signal set.
+  /**
+   * This function destroys the signal set, cancelling any outstanding
+   * asynchronous wait operations associated with the signal set as if by
+   * calling @c cancel.
+   */
+  ~signal_set()
+  {
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<detail::signal_set_service>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<detail::signal_set_service>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<detail::signal_set_service>::get_executor();
+  }
+
+  /// 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 asio::system_error Thrown on failure.
+   */
+  void add(int signal_number)
+  {
+    asio::error_code ec;
+    this->get_service().add(this->get_implementation(), signal_number, ec);
+    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.
+   */
+  ASIO_SYNC_OP_VOID add(int signal_number,
+      asio::error_code& ec)
+  {
+    this->get_service().add(this->get_implementation(), signal_number, ec);
+    ASIO_SYNC_OP_VOID_RETURN(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 asio::system_error Thrown on failure.
+   *
+   * @note Removes any notifications that have been queued for the specified
+   * signal number.
+   */
+  void remove(int signal_number)
+  {
+    asio::error_code ec;
+    this->get_service().remove(this->get_implementation(), signal_number, ec);
+    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.
+   */
+  ASIO_SYNC_OP_VOID remove(int signal_number,
+      asio::error_code& ec)
+  {
+    this->get_service().remove(this->get_implementation(), signal_number, ec);
+    ASIO_SYNC_OP_VOID_RETURN(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 asio::system_error Thrown on failure.
+   *
+   * @note Removes all queued notifications.
+   */
+  void clear()
+  {
+    asio::error_code ec;
+    this->get_service().clear(this->get_implementation(), ec);
+    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.
+   */
+  ASIO_SYNC_OP_VOID clear(asio::error_code& ec)
+  {
+    this->get_service().clear(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(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 asio::error::operation_aborted
+   * error code.
+   *
+   * Cancellation does not alter the set of registered signals.
+   *
+   * @throws asio::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()
+  {
+    asio::error_code ec;
+    this->get_service().cancel(this->get_implementation(), ec);
+    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 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.
+   */
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
+  {
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(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 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 asio::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
+   * asio::io_context::post().
+   */
+  template <typename SignalHandler>
+  ASIO_INITFN_RESULT_TYPE(SignalHandler,
+      void (asio::error_code, int))
+  async_wait(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.
+    ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
+
+    async_completion<SignalHandler,
+      void (asio::error_code, int)> init(handler);
+
+    this->get_service().async_wait(this->get_implementation(),
+        init.completion_handler);
+
+    return init.result.get();
+  }
+};
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 } // namespace asio
 
diff --git a/extern/include/asio/signal_set_service.hpp b/extern/include/asio/signal_set_service.hpp
index 1d25af7a..3285beb0 100644
--- a/extern/include/asio/signal_set_service.hpp
+++ b/extern/include/asio/signal_set_service.hpp
@@ -2,7 +2,7 @@
 // signal_set_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/async_result.hpp"
 #include "asio/detail/signal_set_service.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -28,7 +31,7 @@ namespace asio {
 /// Default service implementation for a signal set.
 class signal_set_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<signal_set_service>
 #endif
@@ -36,7 +39,7 @@ class signal_set_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
 public:
@@ -47,10 +50,10 @@ class signal_set_service
   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(asio::io_service& io_service)
-    : asio::detail::service_base<signal_set_service>(io_service),
-      service_impl_(io_service)
+  /// Construct a new signal set service for the specified io_context.
+  explicit signal_set_service(asio::io_context& io_context)
+    : asio::detail::service_base<signal_set_service>(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -67,31 +70,35 @@ class signal_set_service
   }
 
   /// Add a signal to a signal_set.
-  asio::error_code add(implementation_type& impl,
+  ASIO_SYNC_OP_VOID add(implementation_type& impl,
       int signal_number, asio::error_code& ec)
   {
-    return service_impl_.add(impl, signal_number, ec);
+    service_impl_.add(impl, signal_number, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Remove a signal to a signal_set.
-  asio::error_code remove(implementation_type& impl,
+  ASIO_SYNC_OP_VOID remove(implementation_type& impl,
       int signal_number, asio::error_code& ec)
   {
-    return service_impl_.remove(impl, signal_number, ec);
+    service_impl_.remove(impl, signal_number, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Remove all signals from a signal_set.
-  asio::error_code clear(implementation_type& impl,
+  ASIO_SYNC_OP_VOID clear(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.clear(impl, ec);
+    service_impl_.clear(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Cancel all operations associated with the signal set.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   // Start an asynchronous operation to wait for a signal to be delivered.
@@ -101,26 +108,25 @@ class signal_set_service
   async_wait(implementation_type& impl,
       ASIO_MOVE_ARG(SignalHandler) handler)
   {
-    detail::async_result_init<
-      SignalHandler, void (asio::error_code, int)> init(
-        ASIO_MOVE_CAST(SignalHandler)(handler));
+    async_completion<SignalHandler,
+      void (asio::error_code, int)> init(handler);
 
-    service_impl_.async_wait(impl, init.handler);
+    service_impl_.async_wait(impl, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // Perform any fork-related housekeeping.
-  void fork_service(asio::io_service::fork_event event)
+  void notify_fork(asio::io_context::fork_event event)
   {
-    service_impl_.fork_service(event);
+    service_impl_.notify_fork(event);
   }
 
   // The platform-specific implementation.
@@ -131,4 +137,6 @@ class signal_set_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_SIGNAL_SET_SERVICE_HPP
diff --git a/extern/include/asio/socket_acceptor_service.hpp b/extern/include/asio/socket_acceptor_service.hpp
index 73d91f3f..cd40fe14 100644
--- a/extern/include/asio/socket_acceptor_service.hpp
+++ b/extern/include/asio/socket_acceptor_service.hpp
@@ -2,7 +2,7 @@
 // socket_acceptor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,10 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include "asio/basic_socket.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/null_socket_service.hpp"
@@ -37,7 +40,7 @@ namespace asio {
 template <typename Protocol>
 class socket_acceptor_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<socket_acceptor_service<Protocol> >
 #endif
@@ -45,7 +48,7 @@ class socket_acceptor_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The protocol type.
@@ -72,13 +75,6 @@ class socket_acceptor_service
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (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_handle_type native_type;
-#endif
-
   /// The native acceptor type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_handle_type;
@@ -86,11 +82,11 @@ class socket_acceptor_service
   typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new socket acceptor service for the specified io_service.
-  explicit socket_acceptor_service(asio::io_service& io_service)
+  /// Construct a new socket acceptor service for the specified io_context.
+  explicit socket_acceptor_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        socket_acceptor_service<Protocol> >(io_service),
-      service_impl_(io_service)
+        socket_acceptor_service<Protocol> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -116,17 +112,21 @@ class socket_acceptor_service
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
 
+  // All acceptor services have access to each other's implementations.
+  template <typename Protocol1> friend class socket_acceptor_service;
+
   /// Move-construct a new socket acceptor implementation from another protocol
   /// type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      socket_acceptor_service<Protocol1>& other_service,
       typename socket_acceptor_service<
         Protocol1>::implementation_type& other_impl,
       typename enable_if<is_convertible<
         Protocol1, Protocol>::value>::type* = 0)
   {
     service_impl_.template converting_move_construct<Protocol1>(
-        impl, other_impl);
+        impl, other_service.service_impl_, other_impl);
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
@@ -137,18 +137,20 @@ class socket_acceptor_service
   }
 
   /// Open a new socket acceptor implementation.
-  asio::error_code open(implementation_type& impl,
+  ASIO_SYNC_OP_VOID open(implementation_type& impl,
       const protocol_type& protocol, asio::error_code& ec)
   {
-    return service_impl_.open(impl, protocol, ec);
+    service_impl_.open(impl, protocol, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native acceptor to a socket acceptor.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const protocol_type& protocol, const native_handle_type& native_acceptor,
       asio::error_code& ec)
   {
-    return service_impl_.assign(impl, protocol, native_acceptor, ec);
+    service_impl_.assign(impl, protocol, native_acceptor, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the acceptor is open.
@@ -158,38 +160,43 @@ class socket_acceptor_service
   }
 
   /// Cancel all asynchronous operations associated with the acceptor.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Bind the socket acceptor to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
+  ASIO_SYNC_OP_VOID bind(implementation_type& impl,
       const endpoint_type& endpoint, asio::error_code& ec)
   {
-    return service_impl_.bind(impl, endpoint, ec);
+    service_impl_.bind(impl, endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Place the socket acceptor into the state where it will listen for new
   /// connections.
-  asio::error_code listen(implementation_type& impl, int backlog,
+  ASIO_SYNC_OP_VOID listen(implementation_type& impl, int backlog,
       asio::error_code& ec)
   {
-    return service_impl_.listen(impl, backlog, ec);
+    service_impl_.listen(impl, backlog, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Close a socket acceptor implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native acceptor implementation.
-  native_type native(implementation_type& impl)
+  /// Release ownership of the underlying acceptor.
+  native_handle_type release(implementation_type& impl,
+      asio::error_code& ec)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.release(impl, ec);
   }
 
   /// Get the native acceptor implementation.
@@ -200,26 +207,29 @@ class socket_acceptor_service
 
   /// Set a socket option.
   template <typename SettableSocketOption>
-  asio::error_code set_option(implementation_type& impl,
+  ASIO_SYNC_OP_VOID set_option(implementation_type& impl,
       const SettableSocketOption& option, asio::error_code& ec)
   {
-    return service_impl_.set_option(impl, option, ec);
+    service_impl_.set_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
-  asio::error_code get_option(const implementation_type& impl,
+  ASIO_SYNC_OP_VOID get_option(const implementation_type& impl,
       GettableSocketOption& option, asio::error_code& ec) const
   {
-    return service_impl_.get_option(impl, option, ec);
+    service_impl_.get_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
-  asio::error_code io_control(implementation_type& impl,
+  ASIO_SYNC_OP_VOID io_control(implementation_type& impl,
       IoControlCommand& command, asio::error_code& ec)
   {
-    return service_impl_.io_control(impl, command, ec);
+    service_impl_.io_control(impl, command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the acceptor.
@@ -229,10 +239,11 @@ class socket_acceptor_service
   }
 
   /// Sets the non-blocking mode of the acceptor.
-  asio::error_code non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.non_blocking(impl, mode, ec);
+    service_impl_.non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native acceptor implementation.
@@ -242,10 +253,11 @@ class socket_acceptor_service
   }
 
   /// Sets the non-blocking mode of the native acceptor implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID native_non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.native_non_blocking(impl, mode, ec);
+    service_impl_.native_non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the local endpoint.
@@ -255,15 +267,51 @@ class socket_acceptor_service
     return service_impl_.local_endpoint(impl, ec);
   }
 
+  /// Wait for the acceptor to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  ASIO_SYNC_OP_VOID wait(implementation_type& impl,
+      socket_base::wait_type w, asio::error_code& ec)
+  {
+    service_impl_.wait(impl, w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the acceptor to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(implementation_type& impl, socket_base::wait_type w,
+      ASIO_MOVE_ARG(WaitHandler) handler)
+  {
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    service_impl_.async_wait(impl, w, init.completion_handler);
+
+    return init.result.get();
+  }
+
   /// Accept a new connection.
   template <typename Protocol1, typename SocketService>
-  asio::error_code accept(implementation_type& impl,
+  ASIO_SYNC_OP_VOID accept(implementation_type& impl,
       basic_socket<Protocol1, SocketService>& peer,
       endpoint_type* peer_endpoint, asio::error_code& ec,
       typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
   {
-    return service_impl_.accept(impl, peer, peer_endpoint, ec);
+    service_impl_.accept(impl, peer, peer_endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Accept a new connection.
+  typename Protocol::socket accept(implementation_type& impl,
+      io_context* peer_io_context, endpoint_type* peer_endpoint,
+      asio::error_code& ec)
+  {
+    return service_impl_.accept(impl, peer_io_context, peer_endpoint, ec);
   }
+#endif // defined(ASIO_HAS_MOVE)
 
   /// Start an asynchronous accept.
   template <typename Protocol1, typename SocketService, typename AcceptHandler>
@@ -275,20 +323,40 @@ class socket_acceptor_service
       ASIO_MOVE_ARG(AcceptHandler) handler,
       typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
   {
-    detail::async_result_init<
-      AcceptHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(AcceptHandler)(handler));
+    async_completion<AcceptHandler,
+      void (asio::error_code)> init(handler);
+
+    service_impl_.async_accept(impl,
+        peer, peer_endpoint, init.completion_handler);
+
+    return init.result.get();
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  /// Start an asynchronous accept.
+  template <typename MoveAcceptHandler>
+  ASIO_INITFN_RESULT_TYPE(MoveAcceptHandler,
+      void (asio::error_code, typename Protocol::socket))
+  async_accept(implementation_type& impl,
+      asio::io_context* peer_io_context, endpoint_type* peer_endpoint,
+      ASIO_MOVE_ARG(MoveAcceptHandler) handler)
+  {
+    async_completion<MoveAcceptHandler,
+      void (asio::error_code,
+        typename Protocol::socket)> init(handler);
 
-    service_impl_.async_accept(impl, peer, peer_endpoint, init.handler);
+    service_impl_.async_accept(impl,
+        peer_io_context, peer_endpoint, init.completion_handler);
 
     return init.result.get();
   }
+#endif // defined(ASIO_HAS_MOVE)
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -299,4 +367,6 @@ class socket_acceptor_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
diff --git a/extern/include/asio/socket_base.hpp b/extern/include/asio/socket_base.hpp
index f8bf9bd8..87ed8408 100644
--- a/extern/include/asio/socket_base.hpp
+++ b/extern/include/asio/socket_base.hpp
@@ -2,7 +2,7 @@
 // socket_base.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -75,6 +75,22 @@ class socket_base
       message_end_of_record = ASIO_OS_DEF(MSG_EOR));
 #endif
 
+  /// Wait types.
+  /**
+   * For use with basic_socket::wait() and basic_socket::async_wait().
+   */
+  enum wait_type
+  {
+    /// Wait for a socket to become ready to read.
+    wait_read,
+
+    /// Wait for a socket to become ready to write.
+    wait_write,
+
+    /// Wait for a socket to have error conditions pending.
+    wait_error
+  };
+
   /// Socket option to permit sending of broadcast messages.
   /**
    * Implements the SOL_SOCKET/SO_BROADCAST socket option.
@@ -82,7 +98,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::udp::socket socket(io_service); 
+   * asio::ip::udp::socket socket(io_context); 
    * ...
    * asio::socket_base::broadcast option(true);
    * socket.set_option(option);
@@ -91,7 +107,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::udp::socket socket(io_service); 
+   * asio::ip::udp::socket socket(io_context); 
    * ...
    * asio::socket_base::broadcast option;
    * socket.get_option(option);
@@ -116,7 +132,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::debug option(true);
    * socket.set_option(option);
@@ -125,7 +141,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::debug option;
    * socket.get_option(option);
@@ -149,7 +165,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::udp::socket socket(io_service); 
+   * asio::ip::udp::socket socket(io_context); 
    * ...
    * asio::socket_base::do_not_route option(true);
    * socket.set_option(option);
@@ -158,7 +174,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::udp::socket socket(io_service); 
+   * asio::ip::udp::socket socket(io_context); 
    * ...
    * asio::socket_base::do_not_route option;
    * socket.get_option(option);
@@ -183,7 +199,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::keep_alive option(true);
    * socket.set_option(option);
@@ -192,7 +208,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::keep_alive option;
    * socket.get_option(option);
@@ -216,7 +232,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::send_buffer_size option(8192);
    * socket.set_option(option);
@@ -225,7 +241,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::send_buffer_size option;
    * socket.get_option(option);
@@ -250,7 +266,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::send_low_watermark option(1024);
    * socket.set_option(option);
@@ -259,7 +275,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::send_low_watermark option;
    * socket.get_option(option);
@@ -284,7 +300,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::receive_buffer_size option(8192);
    * socket.set_option(option);
@@ -293,7 +309,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::receive_buffer_size option;
    * socket.get_option(option);
@@ -318,7 +334,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::receive_low_watermark option(1024);
    * socket.set_option(option);
@@ -327,7 +343,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::receive_low_watermark option;
    * socket.get_option(option);
@@ -353,7 +369,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * asio::ip::tcp::acceptor acceptor(io_context); 
    * ...
    * asio::socket_base::reuse_address option(true);
    * acceptor.set_option(option);
@@ -362,7 +378,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * asio::ip::tcp::acceptor acceptor(io_context); 
    * ...
    * asio::socket_base::reuse_address option;
    * acceptor.get_option(option);
@@ -388,7 +404,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::linger option(true, 30);
    * socket.set_option(option);
@@ -397,7 +413,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::linger option;
    * socket.get_option(option);
@@ -416,6 +432,40 @@ class socket_base
       linger;
 #endif
 
+  /// Socket option for putting received out-of-band data inline.
+  /**
+   * Implements the SOL_SOCKET/SO_OOBINLINE socket option.
+   *
+   * @par Examples
+   * Setting the option:
+   * @code
+   * asio::ip::tcp::socket socket(io_context);
+   * ...
+   * asio::socket_base::out_of_band_inline option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * asio::ip::tcp::socket socket(io_context);
+   * ...
+   * asio::socket_base::out_of_band_inline option;
+   * socket.get_option(option);
+   * bool value = option.value();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined out_of_band_inline;
+#else
+  typedef asio::detail::socket_option::boolean<
+    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_OOBINLINE)>
+      out_of_band_inline;
+#endif
+
   /// Socket option to report aborted connections on accept.
   /**
    * Implements a custom socket option that determines whether or not an accept
@@ -425,7 +475,7 @@ class socket_base
    * @par Examples
    * Setting the option:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * asio::ip::tcp::acceptor acceptor(io_context); 
    * ...
    * asio::socket_base::enable_connection_aborted option(true);
    * acceptor.set_option(option);
@@ -434,7 +484,7 @@ class socket_base
    * @par
    * Getting the current option value:
    * @code
-   * asio::ip::tcp::acceptor acceptor(io_service); 
+   * asio::ip::tcp::acceptor acceptor(io_context); 
    * ...
    * asio::socket_base::enable_connection_aborted option;
    * acceptor.get_option(option);
@@ -453,28 +503,6 @@ class socket_base
     enable_connection_aborted;
 #endif
 
-  /// (Deprecated: Use non_blocking().) IO control command to
-  /// set the blocking mode of the socket.
-  /**
-   * Implements the FIONBIO IO control command.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(io_service); 
-   * ...
-   * asio::socket_base::non_blocking_io command(true);
-   * socket.io_control(command);
-   * @endcode
-   *
-   * @par Concepts:
-   * IO_Control_Command, Boolean_IO_Control_Command.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined non_blocking_io;
-#else
-  typedef asio::detail::io_control::non_blocking_io non_blocking_io;
-#endif
-
   /// IO control command to get the amount of data that can be read without
   /// blocking.
   /**
@@ -482,7 +510,7 @@ class socket_base
    *
    * @par Example
    * @code
-   * asio::ip::tcp::socket socket(io_service); 
+   * asio::ip::tcp::socket socket(io_context); 
    * ...
    * asio::socket_base::bytes_readable command(true);
    * socket.io_control(command);
@@ -499,12 +527,23 @@ class socket_base
 #endif
 
   /// The maximum length of the queue of pending incoming connections.
+#if defined(GENERATING_DOCUMENTATION)
+  static const int max_listen_connections = implementation_defined;
+#else
+  ASIO_STATIC_CONSTANT(int, max_listen_connections
+      = ASIO_OS_DEF(SOMAXCONN));
+#endif
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use max_listen_connections.) The maximum length of the queue
+  /// of pending incoming connections.
 #if defined(GENERATING_DOCUMENTATION)
   static const int max_connections = implementation_defined;
 #else
   ASIO_STATIC_CONSTANT(int, max_connections
       = ASIO_OS_DEF(SOMAXCONN));
 #endif
+#endif // !defined(ASIO_NO_DEPRECATED)
 
 protected:
   /// Protected destructor to prevent deletion through this type.
diff --git a/extern/include/asio/spawn.hpp b/extern/include/asio/spawn.hpp
index a9cbbf74..a91c5815 100644
--- a/extern/include/asio/spawn.hpp
+++ b/extern/include/asio/spawn.hpp
@@ -2,7 +2,7 @@
 // spawn.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,13 @@
 
 #include "asio/detail/config.hpp"
 #include <boost/coroutine/all.hpp>
-#include "asio/detail/weak_ptr.hpp"
+#include "asio/bind_executor.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/type_traits.hpp"
 #include "asio/detail/wrapped_handler.hpp"
-#include "asio/io_service.hpp"
+#include "asio/executor.hpp"
+#include "asio/io_context.hpp"
+#include "asio/is_executor.hpp"
 #include "asio/strand.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -94,6 +98,19 @@ class basic_yield_context
   {
   }
 
+  /// Construct a yield context from another yield context type.
+  /**
+   * Requires that OtherHandler be convertible to Handler.
+   */
+  template <typename OtherHandler>
+  basic_yield_context(const basic_yield_context<OtherHandler>& other)
+    : coro_(other.coro_),
+      ca_(other.ca_),
+      handler_(other.handler_),
+      ec_(other.ec_)
+  {
+  }
+
   /// Return a yield context that sets the specified error_code.
   /**
    * By default, when a yield context is used with an asynchronous operation, a
@@ -125,7 +142,7 @@ class basic_yield_context
 #endif // defined(GENERATING_DOCUMENTATION)
   detail::weak_ptr<callee_type> coro_;
   caller_type& ca_;
-  Handler& handler_;
+  Handler handler_;
   asio::error_code* ec_;
 };
 
@@ -134,9 +151,7 @@ class basic_yield_context
 typedef basic_yield_context<unspecified> yield_context;
 #else // defined(GENERATING_DOCUMENTATION)
 typedef basic_yield_context<
-  detail::wrapped_handler<
-    io_service::strand, void(*)(),
-    detail::is_continuation_if_running> > yield_context;
+  executor_binder<void(*)(), executor> > yield_context;
 #endif // defined(GENERATING_DOCUMENTATION)
 
 /**
@@ -175,6 +190,21 @@ typedef basic_yield_context<
  */
 /*@{*/
 
+/// Start a new stackful coroutine, calling the specified handler when it
+/// completes.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(basic_yield_context<Handler> yield); @endcode
+ *
+ * @param attributes Boost.Coroutine attributes used to customise the coroutine.
+ */
+template <typename Function>
+void spawn(ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes
+      = boost::coroutines::attributes());
+
 /// Start a new stackful coroutine, calling the specified handler when it
 /// completes.
 /**
@@ -194,7 +224,9 @@ template <typename Handler, typename Function>
 void spawn(ASIO_MOVE_ARG(Handler) handler,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes());
+      = boost::coroutines::attributes(),
+    typename enable_if<!is_executor<typename decay<Handler>::type>::value &&
+      !is_convertible<Handler&, execution_context&>::value>::type* = 0);
 
 /// Start a new stackful coroutine, inheriting the execution context of another.
 /**
@@ -217,31 +249,49 @@ void spawn(basic_yield_context<Handler> ctx,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
-/// Start a new stackful coroutine that executes in the context of a strand.
+/// Start a new stackful coroutine that executes on a given executor.
 /**
  * This function is used to launch a new coroutine.
  *
- * @param strand Identifies a strand. By starting multiple coroutines on the
- * same strand, the implementation ensures that none of those coroutines can
- * execute simultaneously.
+ * @param ex Identifies the executor that will run the coroutine. The new
+ * coroutine is implicitly given its own strand within this executor.
  *
  * @param function The coroutine function. The function must have the signature:
  * @code void function(yield_context yield); @endcode
  *
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
-template <typename Function>
-void spawn(asio::io_service::strand strand,
+template <typename Function, typename Executor>
+void spawn(const Executor& ex,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes
+      = boost::coroutines::attributes(),
+    typename enable_if<is_executor<Executor>::value>::type* = 0);
+
+/// Start a new stackful coroutine that executes on a given strand.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param ex Identifies the strand that will run the coroutine.
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(yield_context yield); @endcode
+ *
+ * @param attributes Boost.Coroutine attributes used to customise the coroutine.
+ */
+template <typename Function, typename Executor>
+void spawn(const strand<Executor>& ex,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
-/// Start a new stackful coroutine that executes on a given io_service.
+/// Start a new stackful coroutine that executes in the context of a strand.
 /**
  * This function is used to launch a new coroutine.
  *
- * @param io_service Identifies the io_service that will run the coroutine. The
- * new coroutine is implicitly given its own strand within this io_service.
+ * @param s Identifies a strand. By starting multiple coroutines on the same
+ * strand, the implementation ensures that none of those coroutines can execute
+ * simultaneously.
  *
  * @param function The coroutine function. The function must have the signature:
  * @code void function(yield_context yield); @endcode
@@ -249,11 +299,32 @@ void spawn(asio::io_service::strand strand,
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Function>
-void spawn(asio::io_service& io_service,
+void spawn(const asio::io_context::strand& s,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
+/// Start a new stackful coroutine that executes on a given execution context.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param ctx Identifies the execution context that will run the coroutine. The
+ * new coroutine is implicitly given its own strand within this execution
+ * context.
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(yield_context yield); @endcode
+ *
+ * @param attributes Boost.Coroutine attributes used to customise the coroutine.
+ */
+template <typename Function, typename ExecutionContext>
+void spawn(ExecutionContext& ctx,
+    ASIO_MOVE_ARG(Function) function,
+    const boost::coroutines::attributes& attributes
+      = boost::coroutines::attributes(),
+    typename enable_if<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type* = 0);
+
 /*@}*/
 
 } // namespace asio
diff --git a/extern/include/asio/ssl.hpp b/extern/include/asio/ssl.hpp
index 62214610..cbad19d8 100644
--- a/extern/include/asio/ssl.hpp
+++ b/extern/include/asio/ssl.hpp
@@ -2,7 +2,7 @@
 // ssl.hpp
 // ~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,15 +15,12 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include "asio/ssl/basic_context.hpp"
 #include "asio/ssl/context.hpp"
 #include "asio/ssl/context_base.hpp"
-#include "asio/ssl/context_service.hpp"
 #include "asio/ssl/error.hpp"
 #include "asio/ssl/rfc2818_verification.hpp"
 #include "asio/ssl/stream.hpp"
 #include "asio/ssl/stream_base.hpp"
-#include "asio/ssl/stream_service.hpp"
 #include "asio/ssl/verify_context.hpp"
 #include "asio/ssl/verify_mode.hpp"
 
diff --git a/extern/include/asio/ssl/basic_context.hpp b/extern/include/asio/ssl/basic_context.hpp
deleted file mode 100644
index cd41b18c..00000000
--- a/extern/include/asio/ssl/basic_context.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// ssl/basic_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_BASIC_CONTEXT_HPP
-#define ASIO_SSL_BASIC_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/old/basic_context.hpp"
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-#if defined(ASIO_ENABLE_OLD_SSL)
-
-using asio::ssl::old::basic_context;
-
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_BASIC_CONTEXT_HPP
diff --git a/extern/include/asio/ssl/context.hpp b/extern/include/asio/ssl/context.hpp
index 936e5eef..9543aab6 100644
--- a/extern/include/asio/ssl/context.hpp
+++ b/extern/include/asio/ssl/context.hpp
@@ -2,7 +2,7 @@
 // ssl/context.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,33 +17,21 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/basic_context.hpp"
-# include "asio/ssl/context_service.hpp"
-#else // defined(ASIO_ENABLE_OLD_SSL)
-# include <string>
-# include "asio/buffer.hpp"
-# include "asio/io_service.hpp"
-# include "asio/ssl/context_base.hpp"
-# include "asio/ssl/detail/openssl_types.hpp"
-# include "asio/ssl/detail/openssl_init.hpp"
-# include "asio/ssl/detail/password_callback.hpp"
-# include "asio/ssl/detail/verify_callback.hpp"
-# include "asio/ssl/verify_mode.hpp"
-#endif // defined(ASIO_ENABLE_OLD_SSL)
+#include <string>
+#include "asio/buffer.hpp"
+#include "asio/io_context.hpp"
+#include "asio/ssl/context_base.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
+#include "asio/ssl/detail/openssl_init.hpp"
+#include "asio/ssl/detail/password_callback.hpp"
+#include "asio/ssl/detail/verify_callback.hpp"
+#include "asio/ssl/verify_mode.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace ssl {
 
-#if defined(ASIO_ENABLE_OLD_SSL)
-
-/// Typedef for the typical usage of context.
-typedef basic_context<context_service> context;
-
-#else // defined(ASIO_ENABLE_OLD_SSL)
-
 class context
   : public context_base,
     private noncopyable
@@ -52,15 +40,9 @@ class context
   /// The native handle type of the SSL context.
   typedef SSL_CTX* native_handle_type;
 
-  /// (Deprecated: Use native_handle_type.) The native type of the SSL context.
-  typedef SSL_CTX* impl_type;
-
   /// Constructor.
   ASIO_DECL explicit context(method m);
 
-  /// Deprecated constructor taking a reference to an io_service object.
-  ASIO_DECL context(asio::io_service&, method m);
-
 #if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Move-construct a context from another.
   /**
@@ -100,15 +82,6 @@ class context
    */
   ASIO_DECL native_handle_type native_handle();
 
-  /// (Deprecated: Use native_handle().) Get the underlying implementation in
-  /// the native type.
-  /**
-   * This function may be used to obtain the underlying implementation of the
-   * context. This is intended to allow access to context functionality that is
-   * not otherwise provided.
-   */
-  ASIO_DECL impl_type impl();
-
   /// Clear options on the context.
   /**
    * This function may be used to configure the SSL options used by the context.
@@ -135,7 +108,7 @@ class context
    *
    * @note Calls @c SSL_CTX_clear_options.
    */
-  ASIO_DECL asio::error_code clear_options(options o,
+  ASIO_DECL ASIO_SYNC_OP_VOID clear_options(options o,
       asio::error_code& ec);
 
   /// Set options on the context.
@@ -164,7 +137,7 @@ class context
    *
    * @note Calls @c SSL_CTX_set_options.
    */
-  ASIO_DECL asio::error_code set_options(options o,
+  ASIO_DECL ASIO_SYNC_OP_VOID set_options(options o,
       asio::error_code& ec);
 
   /// Set the peer verification mode.
@@ -193,7 +166,7 @@ class context
    *
    * @note Calls @c SSL_CTX_set_verify.
    */
-  ASIO_DECL asio::error_code set_verify_mode(
+  ASIO_DECL ASIO_SYNC_OP_VOID set_verify_mode(
       verify_mode v, asio::error_code& ec);
 
   /// Set the peer verification depth.
@@ -222,7 +195,7 @@ class context
    *
    * @note Calls @c SSL_CTX_set_verify_depth.
    */
-  ASIO_DECL asio::error_code set_verify_depth(
+  ASIO_DECL ASIO_SYNC_OP_VOID set_verify_depth(
       int depth, asio::error_code& ec);
 
   /// Set the callback used to verify peer certificates.
@@ -265,7 +238,7 @@ class context
    * @note Calls @c SSL_CTX_set_verify.
    */
   template <typename VerifyCallback>
-  asio::error_code set_verify_callback(VerifyCallback callback,
+  ASIO_SYNC_OP_VOID set_verify_callback(VerifyCallback callback,
       asio::error_code& ec);
 
   /// Load a certification authority file for performing verification.
@@ -294,7 +267,7 @@ class context
    *
    * @note Calls @c SSL_CTX_load_verify_locations.
    */
-  ASIO_DECL asio::error_code load_verify_file(
+  ASIO_DECL ASIO_SYNC_OP_VOID load_verify_file(
       const std::string& filename, asio::error_code& ec);
 
   /// Add certification authority for performing verification.
@@ -323,7 +296,7 @@ class context
    *
    * @note Calls @c SSL_CTX_get_cert_store and @c X509_STORE_add_cert.
    */
-  ASIO_DECL asio::error_code add_certificate_authority(
+  ASIO_DECL ASIO_SYNC_OP_VOID add_certificate_authority(
       const const_buffer& ca, asio::error_code& ec);
 
   /// Configures the context to use the default directories for finding
@@ -350,7 +323,7 @@ class context
    *
    * @note Calls @c SSL_CTX_set_default_verify_paths.
    */
-  ASIO_DECL asio::error_code set_default_verify_paths(
+  ASIO_DECL ASIO_SYNC_OP_VOID set_default_verify_paths(
       asio::error_code& ec);
 
   /// Add a directory containing certificate authority files to be used for
@@ -383,7 +356,7 @@ class context
    *
    * @note Calls @c SSL_CTX_load_verify_locations.
    */
-  ASIO_DECL asio::error_code add_verify_path(
+  ASIO_DECL ASIO_SYNC_OP_VOID add_verify_path(
       const std::string& path, asio::error_code& ec);
 
   /// Use a certificate from a memory buffer.
@@ -413,7 +386,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_certificate or SSL_CTX_use_certificate_ASN1.
    */
-  ASIO_DECL asio::error_code use_certificate(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate(
       const const_buffer& certificate, file_format format,
       asio::error_code& ec);
 
@@ -444,7 +417,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_certificate_file.
    */
-  ASIO_DECL asio::error_code use_certificate_file(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate_file(
       const std::string& filename, file_format format,
       asio::error_code& ec);
 
@@ -474,7 +447,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_certificate and SSL_CTX_add_extra_chain_cert.
    */
-  ASIO_DECL asio::error_code use_certificate_chain(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate_chain(
       const const_buffer& chain, asio::error_code& ec);
 
   /// Use a certificate chain from a file.
@@ -503,7 +476,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_certificate_chain_file.
    */
-  ASIO_DECL asio::error_code use_certificate_chain_file(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate_chain_file(
       const std::string& filename, asio::error_code& ec);
 
   /// Use a private key from a memory buffer.
@@ -533,7 +506,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_PrivateKey or SSL_CTX_use_PrivateKey_ASN1.
    */
-  ASIO_DECL asio::error_code use_private_key(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_private_key(
       const const_buffer& private_key, file_format format,
       asio::error_code& ec);
 
@@ -564,7 +537,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_PrivateKey_file.
    */
-  ASIO_DECL asio::error_code use_private_key_file(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_private_key_file(
       const std::string& filename, file_format format,
       asio::error_code& ec);
 
@@ -597,7 +570,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_RSAPrivateKey or SSL_CTX_use_RSAPrivateKey_ASN1.
    */
-  ASIO_DECL asio::error_code use_rsa_private_key(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_rsa_private_key(
       const const_buffer& private_key, file_format format,
       asio::error_code& ec);
 
@@ -630,7 +603,7 @@ class context
    *
    * @note Calls @c SSL_CTX_use_RSAPrivateKey_file.
    */
-  ASIO_DECL asio::error_code use_rsa_private_key_file(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_rsa_private_key_file(
       const std::string& filename, file_format format,
       asio::error_code& ec);
 
@@ -662,7 +635,7 @@ class context
    *
    * @note Calls @c SSL_CTX_set_tmp_dh.
    */
-  ASIO_DECL asio::error_code use_tmp_dh(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_tmp_dh(
       const const_buffer& dh, asio::error_code& ec);
 
   /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
@@ -691,7 +664,7 @@ class context
    *
    * @note Calls @c SSL_CTX_set_tmp_dh.
    */
-  ASIO_DECL asio::error_code use_tmp_dh_file(
+  ASIO_DECL ASIO_SYNC_OP_VOID use_tmp_dh_file(
       const std::string& filename, asio::error_code& ec);
 
   /// Set the password callback.
@@ -732,7 +705,7 @@ class context
    * @note Calls @c SSL_CTX_set_default_passwd_cb.
    */
   template <typename PasswordCallback>
-  asio::error_code set_password_callback(PasswordCallback callback,
+  ASIO_SYNC_OP_VOID set_password_callback(PasswordCallback callback,
       asio::error_code& ec);
 
 private:
@@ -743,7 +716,7 @@ class context
   struct dh_cleanup;
 
   // Helper function used to set a peer certificate verification callback.
-  ASIO_DECL asio::error_code do_set_verify_callback(
+  ASIO_DECL ASIO_SYNC_OP_VOID do_set_verify_callback(
       detail::verify_callback_base* callback, asio::error_code& ec);
 
   // Callback used when the SSL implementation wants to verify a certificate.
@@ -751,7 +724,7 @@ class context
       int preverified, X509_STORE_CTX* ctx);
 
   // Helper function used to set a password callback.
-  ASIO_DECL asio::error_code do_set_password_callback(
+  ASIO_DECL ASIO_SYNC_OP_VOID do_set_password_callback(
       detail::password_callback_base* callback, asio::error_code& ec);
 
   // Callback used when the SSL implementation wants a password.
@@ -759,7 +732,7 @@ class context
       char* buf, int size, int purpose, void* data);
 
   // Helper function to set the temporary Diffie-Hellman parameters from a BIO.
-  ASIO_DECL asio::error_code do_use_tmp_dh(
+  ASIO_DECL ASIO_SYNC_OP_VOID do_use_tmp_dh(
       BIO* bio, asio::error_code& ec);
 
   // Helper function to make a BIO from a memory buffer.
@@ -772,8 +745,6 @@ class context
   asio::ssl::detail::openssl_init<> init_;
 };
 
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace ssl
 } // namespace asio
 
diff --git a/extern/include/asio/ssl/context_base.hpp b/extern/include/asio/ssl/context_base.hpp
index cfa2f42e..56c76936 100644
--- a/extern/include/asio/ssl/context_base.hpp
+++ b/extern/include/asio/ssl/context_base.hpp
@@ -2,7 +2,7 @@
 // ssl/context_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -83,7 +83,16 @@ class context_base
     tlsv12_client,
 
     /// TLS version 1.2 server.
-    tlsv12_server
+    tlsv12_server,
+
+    /// Generic TLS.
+    tls,
+
+    /// TLS client.
+    tls_client,
+
+    /// TLS server.
+    tls_server
   };
 
   /// Bitmask type for SSL options.
diff --git a/extern/include/asio/ssl/context_service.hpp b/extern/include/asio/ssl/context_service.hpp
deleted file mode 100644
index a4ffe9b2..00000000
--- a/extern/include/asio/ssl/context_service.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// ssl/context_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_CONTEXT_SERVICE_HPP
-#define ASIO_SSL_CONTEXT_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-  
-#if defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/old/context_service.hpp"
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-#if defined(ASIO_ENABLE_OLD_SSL)
-
-using asio::ssl::old::context_service;
-
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_CONTEXT_SERVICE_HPP
diff --git a/extern/include/asio/ssl/detail/buffered_handshake_op.hpp b/extern/include/asio/ssl/detail/buffered_handshake_op.hpp
index c93e7872..38a03fcc 100644
--- a/extern/include/asio/ssl/detail/buffered_handshake_op.hpp
+++ b/extern/include/asio/ssl/detail/buffered_handshake_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/buffered_handshake_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,7 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/detail/engine.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/ssl/detail/engine.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -27,8 +25,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 template <typename ConstBufferSequence>
 class buffered_handshake_op
 {
@@ -45,8 +41,27 @@ class buffered_handshake_op
       asio::error_code& ec,
       std::size_t& bytes_transferred) const
   {
-    typename ConstBufferSequence::const_iterator iter = buffers_.begin();
-    typename ConstBufferSequence::const_iterator end = buffers_.end();
+    return this->process(eng, ec, bytes_transferred,
+        asio::buffer_sequence_begin(buffers_),
+        asio::buffer_sequence_end(buffers_));
+  }
+
+  template <typename Handler>
+  void call_handler(Handler& handler,
+      const asio::error_code& ec,
+      const std::size_t& bytes_transferred) const
+  {
+    handler(ec, bytes_transferred);
+  }
+
+private:
+  template <typename Iterator>
+  engine::want process(engine& eng,
+      asio::error_code& ec,
+      std::size_t& bytes_transferred,
+      Iterator begin, Iterator end) const
+  {
+    Iterator iter = begin;
     std::size_t accumulated_size = 0;
 
     for (;;)
@@ -62,9 +77,9 @@ class buffered_handshake_op
         const_buffer buffer(*iter);
 
         // Skip over any buffers which have already been consumed by the engine.
-        if (bytes_transferred >= accumulated_size + buffer_size(buffer))
+        if (bytes_transferred >= accumulated_size + buffer.size())
         {
-          accumulated_size += buffer_size(buffer);
+          accumulated_size += buffer.size();
           ++iter;
           continue;
         }
@@ -77,30 +92,19 @@ class buffered_handshake_op
 
         // Pass the buffer to the engine, and update the bytes transferred to
         // reflect the total number of bytes consumed so far.
-        bytes_transferred += buffer_size(buffer);
+        bytes_transferred += buffer.size();
         buffer = eng.put_input(buffer);
-        bytes_transferred -= buffer_size(buffer);
+        bytes_transferred -= buffer.size();
         break;
       }
     }
   }
 
-  template <typename Handler>
-  void call_handler(Handler& handler,
-      const asio::error_code& ec,
-      const std::size_t& bytes_transferred) const
-  {
-    handler(ec, bytes_transferred);
-  }
-
-private:
   stream_base::handshake_type type_;
   ConstBufferSequence buffers_;
   std::size_t total_buffer_size_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/engine.hpp b/extern/include/asio/ssl/detail/engine.hpp
index e56ed1bb..2f033d66 100644
--- a/extern/include/asio/ssl/detail/engine.hpp
+++ b/extern/include/asio/ssl/detail/engine.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/engine.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,14 +17,12 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/buffer.hpp"
-# include "asio/detail/static_mutex.hpp"
-# include "asio/ssl/detail/openssl_types.hpp"
-# include "asio/ssl/detail/verify_callback.hpp"
-# include "asio/ssl/stream_base.hpp"
-# include "asio/ssl/verify_mode.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/buffer.hpp"
+#include "asio/detail/static_mutex.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
+#include "asio/ssl/detail/verify_callback.hpp"
+#include "asio/ssl/stream_base.hpp"
+#include "asio/ssl/verify_mode.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -32,8 +30,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 class engine
 {
 public:
@@ -97,7 +93,7 @@ class engine
       asio::error_code& ec, std::size_t& bytes_transferred);
 
   // Get output data to be written to the transport.
-  ASIO_DECL asio::mutable_buffers_1 get_output(
+  ASIO_DECL asio::mutable_buffer get_output(
       const asio::mutable_buffer& data);
 
   // Put input data that was read from the transport.
@@ -119,9 +115,11 @@ class engine
   ASIO_DECL static int verify_callback_function(
       int preverified, X509_STORE_CTX* ctx);
 
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
   // The SSL_accept function may not be thread safe. This mutex is used to
   // protect all calls to the SSL_accept function.
   ASIO_DECL static asio::detail::static_mutex& accept_mutex();
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
 
   // Perform one operation. Returns >= 0 on success or error, want_read if the
   // operation needs more input, or want_write if it needs to write some output
@@ -149,8 +147,6 @@ class engine
   BIO* ext_bio_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/handshake_op.hpp b/extern/include/asio/ssl/detail/handshake_op.hpp
index 066e0302..f782023a 100644
--- a/extern/include/asio/ssl/detail/handshake_op.hpp
+++ b/extern/include/asio/ssl/detail/handshake_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/handshake_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,7 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/detail/engine.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/ssl/detail/engine.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -27,8 +25,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 class handshake_op
 {
 public:
@@ -57,8 +53,6 @@ class handshake_op
   stream_base::handshake_type type_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/impl/engine.ipp b/extern/include/asio/ssl/detail/impl/engine.ipp
index 139d7397..e60e8d6f 100644
--- a/extern/include/asio/ssl/detail/impl/engine.ipp
+++ b/extern/include/asio/ssl/detail/impl/engine.ipp
@@ -2,7 +2,7 @@
 // ssl/detail/impl/engine.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,13 +17,11 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/detail/throw_error.hpp"
-# include "asio/error.hpp"
-# include "asio/ssl/detail/engine.hpp"
-# include "asio/ssl/error.hpp"
-# include "asio/ssl/verify_context.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+#include "asio/ssl/detail/engine.hpp"
+#include "asio/ssl/error.hpp"
+#include "asio/ssl/verify_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -31,8 +29,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 engine::engine(SSL_CTX* context)
   : ssl_(::SSL_new(context))
 {
@@ -44,7 +40,9 @@ engine::engine(SSL_CTX* context)
     asio::detail::throw_error(ec, "engine");
   }
 
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
   accept_mutex().init();
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
 
   ::SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE);
   ::SSL_set_mode(ssl_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
@@ -145,37 +143,35 @@ engine::want engine::shutdown(asio::error_code& ec)
 engine::want engine::write(const asio::const_buffer& data,
     asio::error_code& ec, std::size_t& bytes_transferred)
 {
-  if (asio::buffer_size(data) == 0)
+  if (data.size() == 0)
   {
     ec = asio::error_code();
     return engine::want_nothing;
   }
 
   return perform(&engine::do_write,
-      const_cast<void*>(asio::buffer_cast<const void*>(data)),
-      asio::buffer_size(data), ec, &bytes_transferred);
+      const_cast<void*>(data.data()),
+      data.size(), ec, &bytes_transferred);
 }
 
 engine::want engine::read(const asio::mutable_buffer& data,
     asio::error_code& ec, std::size_t& bytes_transferred)
 {
-  if (asio::buffer_size(data) == 0)
+  if (data.size() == 0)
   {
     ec = asio::error_code();
     return engine::want_nothing;
   }
 
-  return perform(&engine::do_read,
-      asio::buffer_cast<void*>(data),
-      asio::buffer_size(data), ec, &bytes_transferred);
+  return perform(&engine::do_read, data.data(),
+      data.size(), ec, &bytes_transferred);
 }
 
-asio::mutable_buffers_1 engine::get_output(
+asio::mutable_buffer engine::get_output(
     const asio::mutable_buffer& data)
 {
   int length = ::BIO_read(ext_bio_,
-      asio::buffer_cast<void*>(data),
-      static_cast<int>(asio::buffer_size(data)));
+      data.data(), static_cast<int>(data.size()));
 
   return asio::buffer(data,
       length > 0 ? static_cast<std::size_t>(length) : 0);
@@ -185,8 +181,7 @@ asio::const_buffer engine::put_input(
     const asio::const_buffer& data)
 {
   int length = ::BIO_write(ext_bio_,
-      asio::buffer_cast<const void*>(data),
-      static_cast<int>(asio::buffer_size(data)));
+      data.data(), static_cast<int>(data.size()));
 
   return asio::buffer(data +
       (length > 0 ? static_cast<std::size_t>(length) : 0));
@@ -202,33 +197,33 @@ const asio::error_code& engine::map_error_code(
   // If there's data yet to be read, it's an error.
   if (BIO_wpending(ext_bio_))
   {
-    ec = asio::error_code(
-        ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ),
-        asio::error::get_ssl_category());
+    ec = asio::ssl::error::stream_truncated;
     return ec;
   }
 
   // SSL v2 doesn't provide a protocol-level shutdown, so an eof on the
   // underlying transport is passed through.
-  if (ssl_->version == SSL2_VERSION)
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
+  if (SSL_version(ssl_) == SSL2_VERSION)
     return ec;
+#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
 
   // Otherwise, the peer should have negotiated a proper shutdown.
   if ((::SSL_get_shutdown(ssl_) & SSL_RECEIVED_SHUTDOWN) == 0)
   {
-    ec = asio::error_code(
-        ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ),
-        asio::error::get_ssl_category());
+    ec = asio::ssl::error::stream_truncated;
   }
 
   return ec;
 }
 
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
 asio::detail::static_mutex& engine::accept_mutex()
 {
   static asio::detail::static_mutex mutex = ASIO_STATIC_MUTEX_INIT;
   return mutex;
 }
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
 
 engine::want engine::perform(int (engine::* op)(void*, std::size_t),
     void* data, std::size_t length, asio::error_code& ec,
@@ -287,7 +282,9 @@ engine::want engine::perform(int (engine::* op)(void*, std::size_t),
 
 int engine::do_accept(void*, std::size_t)
 {
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
   asio::detail::static_mutex::scoped_lock lock(accept_mutex());
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
   return ::SSL_accept(ssl_);
 }
 
@@ -316,8 +313,6 @@ int engine::do_write(void* data, std::size_t length)
       length < INT_MAX ? static_cast<int>(length) : INT_MAX);
 }
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/impl/openssl_init.ipp b/extern/include/asio/ssl/detail/impl/openssl_init.ipp
index da66fc13..fb0fff94 100644
--- a/extern/include/asio/ssl/detail/impl/openssl_init.ipp
+++ b/extern/include/asio/ssl/detail/impl/openssl_init.ipp
@@ -3,7 +3,7 @@
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2005-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -35,6 +35,7 @@ class openssl_init_base::do_init
 public:
   do_init()
   {
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
     ::SSL_library_init();
     ::SSL_load_error_strings();        
     ::OpenSSL_add_all_algorithms();
@@ -43,7 +44,10 @@ public:
     for (size_t i = 0; i < mutexes_.size(); ++i)
       mutexes_[i].reset(new asio::detail::mutex);
     ::CRYPTO_set_locking_callback(&do_init::openssl_locking_func);
+#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
     ::CRYPTO_set_id_callback(&do_init::openssl_id_func);
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
 
 #if !defined(SSL_OP_NO_COMPRESSION) \
   && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
@@ -60,20 +64,35 @@ public:
 #endif // !defined(SSL_OP_NO_COMPRESSION)
        // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
 
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
     ::CRYPTO_set_id_callback(0);
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
     ::CRYPTO_set_locking_callback(0);
     ::ERR_free_strings();
-#if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
-    ::ERR_remove_thread_state(NULL);
-#else // (OPENSSL_VERSION_NUMBER >= 0x10000000L)
-    ::ERR_remove_state(0);
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10000000L)
     ::EVP_cleanup();
     ::CRYPTO_cleanup_all_ex_data();
+#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
+    ::ERR_remove_state(0);
+#elif (OPENSSL_VERSION_NUMBER < 0x10100000L)
+    ::ERR_remove_thread_state(NULL);
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
+#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) \
+    && (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+    && !defined(SSL_OP_NO_COMPRESSION)
+    ::SSL_COMP_free_compression_methods();
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10002000L)
+       // && (OPENSSL_VERSION_NUMBER < 0x10100000L)
+       // && !defined(SSL_OP_NO_COMPRESSION)
+#if !defined(OPENSSL_IS_BORINGSSL)
     ::CONF_modules_unload(1);
-#if !defined(OPENSSL_NO_ENGINE)
+#endif // !defined(OPENSSL_IS_BORINGSSL)
+#if !defined(OPENSSL_NO_ENGINE) \
+  && (OPENSSL_VERSION_NUMBER < 0x10100000L)
     ::ENGINE_cleanup();
 #endif // !defined(OPENSSL_NO_ENGINE)
+       // && (OPENSSL_VERSION_NUMBER < 0x10100000L)
   }
 
 #if !defined(SSL_OP_NO_COMPRESSION) \
@@ -86,19 +105,20 @@ public:
        // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
 
 private:
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
   static unsigned long openssl_id_func()
   {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
     return ::GetCurrentThreadId();
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    void* id = instance()->thread_id_;
-    if (id == 0)
-      instance()->thread_id_ = id = &id; // Ugh.
+    void* id = &errno;
     ASIO_ASSERT(sizeof(unsigned long) >= sizeof(void*));
     return reinterpret_cast<unsigned long>(id);
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   }
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
 
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
   static void openssl_locking_func(int mode, int n, 
     const char* /*file*/, int /*line*/)
   {
@@ -111,11 +131,7 @@ private:
   // Mutexes to be used in locking callbacks.
   std::vector<asio::detail::shared_ptr<
         asio::detail::mutex> > mutexes_;
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-  // The thread identifiers to be used by openssl.
-  asio::detail::tss_ptr<void> thread_id_;
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
+#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
 
 #if !defined(SSL_OP_NO_COMPRESSION) \
   && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
diff --git a/extern/include/asio/ssl/detail/io.hpp b/extern/include/asio/ssl/detail/io.hpp
index 115531b1..0b0e51a2 100644
--- a/extern/include/asio/ssl/detail/io.hpp
+++ b/extern/include/asio/ssl/detail/io.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/io.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,11 +17,9 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/detail/engine.hpp"
-# include "asio/ssl/detail/stream_core.hpp"
-# include "asio/write.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/ssl/detail/engine.hpp"
+#include "asio/ssl/detail/stream_core.hpp"
+#include "asio/write.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -29,8 +27,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 template <typename Stream, typename Operation>
 std::size_t io(Stream& next_layer, stream_core& core,
     const Operation& op, asio::error_code& ec)
@@ -42,7 +38,7 @@ std::size_t io(Stream& next_layer, stream_core& core,
 
     // If the input buffer is empty then we need to read some more data from
     // the underlying transport.
-    if (asio::buffer_size(core.input_) == 0)
+    if (core.input_.size() == 0)
       core.input_ = asio::buffer(core.input_buffer_,
           next_layer.read_some(core.input_buffer_, ec));
 
@@ -118,7 +114,7 @@ class io_op
   io_op(io_op&& other)
     : next_layer_(other.next_layer_),
       core_(other.core_),
-      op_(other.op_),
+      op_(ASIO_MOVE_CAST(Operation)(other.op_)),
       start_(other.start_),
       want_(other.want_),
       ec_(other.ec_),
@@ -142,7 +138,7 @@ class io_op
 
           // If the input buffer already has data in it we can pass it to the
           // engine and then retry the operation immediately.
-          if (asio::buffer_size(core_.input_) != 0)
+          if (core_.input_.size() != 0)
           {
             core_.input_ = core_.engine_.put_input(core_.input_);
             continue;
@@ -152,7 +148,7 @@ class io_op
           // cannot allow more than one read operation at a time on the
           // underlying transport. The pending_read_ timer's expiry is set to
           // pos_infin if a read is in progress, and neg_infin otherwise.
-          if (core_.pending_read_.expires_at() == core_.neg_infin())
+          if (core_.expiry(core_.pending_read_) == core_.neg_infin())
           {
             // Prevent other read operations from being started.
             core_.pending_read_.expires_at(core_.pos_infin());
@@ -179,7 +175,7 @@ class io_op
           // cannot allow more than one write operation at a time on the
           // underlying transport. The pending_write_ timer's expiry is set to
           // pos_infin if a write is in progress, and neg_infin otherwise.
-          if (core_.pending_write_.expires_at() == core_.neg_infin())
+          if (core_.expiry(core_.pending_write_) == core_.neg_infin())
           {
             // Prevent other write operations from being started.
             core_.pending_write_.expires_at(core_.pos_infin());
@@ -205,7 +201,7 @@ class io_op
           // have to keep in mind that this function might be being called from
           // the async operation's initiating function. In this case we're not
           // allowed to call the handler directly. Instead, issue a zero-sized
-          // read so the handler runs "as-if" posted using io_service::post().
+          // read so the handler runs "as-if" posted using io_context::post().
           if (start)
           {
             next_layer_.async_read_some(
@@ -287,7 +283,7 @@ class io_op
   Handler handler_;
 };
 
-template <typename Stream, typename Operation,  typename Handler>
+template <typename Stream, typename Operation, typename Handler>
 inline void* asio_handler_allocate(std::size_t size,
     io_op<Stream, Operation, Handler>* this_handler)
 {
@@ -338,10 +334,37 @@ inline void async_io(Stream& next_layer, stream_core& core,
       asio::error_code(), 0, 1);
 }
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
+
+template <typename Stream, typename Operation,
+    typename Handler, typename Allocator>
+struct associated_allocator<
+    ssl::detail::io_op<Stream, Operation, Handler>, Allocator>
+{
+  typedef typename associated_allocator<Handler, Allocator>::type type;
+
+  static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
+      const Allocator& a = Allocator()) ASIO_NOEXCEPT
+  {
+    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Stream, typename Operation,
+    typename Handler, typename Executor>
+struct associated_executor<
+    ssl::detail::io_op<Stream, Operation, Handler>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
+
+  static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
+      const Executor& ex = Executor()) ASIO_NOEXCEPT
+  {
+    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+  }
+};
+
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
diff --git a/extern/include/asio/ssl/detail/openssl_init.hpp b/extern/include/asio/ssl/detail/openssl_init.hpp
index 7bc92971..c3e47278 100644
--- a/extern/include/asio/ssl/detail/openssl_init.hpp
+++ b/extern/include/asio/ssl/detail/openssl_init.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/openssl_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,8 +17,8 @@
 
 #include "asio/detail/config.hpp"
 #include <cstring>
+#include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
-#include "asio/detail/shared_ptr.hpp"
 #include "asio/ssl/detail/openssl_types.hpp"
 
 #include "asio/detail/push_options.hpp"
diff --git a/extern/include/asio/ssl/detail/openssl_types.hpp b/extern/include/asio/ssl/detail/openssl_types.hpp
index 5a141484..a044af30 100644
--- a/extern/include/asio/ssl/detail/openssl_types.hpp
+++ b/extern/include/asio/ssl/detail/openssl_types.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/openssl_types.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,13 +16,15 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/detail/socket_types.hpp"
 #include <openssl/conf.h>
 #include <openssl/ssl.h>
 #if !defined(OPENSSL_NO_ENGINE)
 # include <openssl/engine.h>
 #endif // !defined(OPENSSL_NO_ENGINE)
+#include <openssl/dh.h>
 #include <openssl/err.h>
+#include <openssl/rsa.h>
 #include <openssl/x509v3.h>
-#include "asio/detail/socket_types.hpp"
 
 #endif // ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
diff --git a/extern/include/asio/ssl/detail/password_callback.hpp b/extern/include/asio/ssl/detail/password_callback.hpp
index 479420e6..9b1dbeeb 100644
--- a/extern/include/asio/ssl/detail/password_callback.hpp
+++ b/extern/include/asio/ssl/detail/password_callback.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/password_callback.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,11 +17,9 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include <cstddef>
-# include <string>
-# include "asio/ssl/context_base.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include <cstddef>
+#include <string>
+#include "asio/ssl/context_base.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -29,8 +27,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 class password_callback_base
 {
 public:
@@ -61,8 +57,6 @@ class password_callback : public password_callback_base
   PasswordCallback callback_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/read_op.hpp b/extern/include/asio/ssl/detail/read_op.hpp
index 8d949ef7..b0d6de26 100644
--- a/extern/include/asio/ssl/detail/read_op.hpp
+++ b/extern/include/asio/ssl/detail/read_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,10 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/detail/buffer_sequence_adapter.hpp"
-# include "asio/ssl/detail/engine.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/ssl/detail/engine.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -28,8 +26,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 template <typename MutableBufferSequence>
 class read_op
 {
@@ -62,8 +58,6 @@ class read_op
   MutableBufferSequence buffers_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/shutdown_op.hpp b/extern/include/asio/ssl/detail/shutdown_op.hpp
index d7f7de7c..d20b4309 100644
--- a/extern/include/asio/ssl/detail/shutdown_op.hpp
+++ b/extern/include/asio/ssl/detail/shutdown_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/shutdown_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,7 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/detail/engine.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/ssl/detail/engine.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -27,8 +25,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 class shutdown_op
 {
 public:
@@ -49,8 +45,6 @@ class shutdown_op
   }
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/stream_core.hpp b/extern/include/asio/ssl/detail/stream_core.hpp
index 4c5c85a4..13fde74b 100644
--- a/extern/include/asio/ssl/detail/stream_core.hpp
+++ b/extern/include/asio/ssl/detail/stream_core.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/stream_core.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,15 +17,13 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# if defined(ASIO_HAS_BOOST_DATE_TIME)
-#  include "asio/deadline_timer.hpp"
-# else // defined(ASIO_HAS_BOOST_DATE_TIME)
-#  include "asio/steady_timer.hpp"
-# endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/ssl/detail/engine.hpp"
-# include "asio/buffer.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#if defined(ASIO_HAS_BOOST_DATE_TIME)
+# include "asio/deadline_timer.hpp"
+#else // defined(ASIO_HAS_BOOST_DATE_TIME)
+# include "asio/steady_timer.hpp"
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+#include "asio/ssl/detail/engine.hpp"
+#include "asio/buffer.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -33,18 +31,16 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 struct stream_core
 {
   // According to the OpenSSL documentation, this is the buffer size that is
   // sufficient to hold the largest possible TLS record.
   enum { max_tls_record_size = 17 * 1024 };
 
-  stream_core(SSL_CTX* context, asio::io_service& io_service)
+  stream_core(SSL_CTX* context, asio::io_context& io_context)
     : engine_(context),
-      pending_read_(io_service),
-      pending_write_(io_service),
+      pending_read_(io_context),
+      pending_write_(io_context),
       output_buffer_space_(max_tls_record_size),
       output_buffer_(asio::buffer(output_buffer_space_)),
       input_buffer_space_(max_tls_record_size),
@@ -79,6 +75,13 @@ struct stream_core
   {
     return boost::posix_time::pos_infin;
   }
+
+  // Helper function to get a timer's expiry time.
+  static asio::deadline_timer::time_type expiry(
+      const asio::deadline_timer& timer)
+  {
+    return timer.expires_at();
+  }
 #else // defined(ASIO_HAS_BOOST_DATE_TIME)
   // Timer used for storing queued read operations.
   asio::steady_timer pending_read_;
@@ -97,26 +100,31 @@ struct stream_core
   {
     return (asio::steady_timer::time_point::max)();
   }
+
+  // Helper function to get a timer's expiry time.
+  static asio::steady_timer::time_point expiry(
+      const asio::steady_timer& timer)
+  {
+    return timer.expiry();
+  }
 #endif // defined(ASIO_HAS_BOOST_DATE_TIME)
 
   // Buffer space used to prepare output intended for the transport.
   std::vector<unsigned char> output_buffer_space_;
 
   // A buffer that may be used to prepare output intended for the transport.
-  const asio::mutable_buffers_1 output_buffer_;
+  const asio::mutable_buffer output_buffer_;
 
   // Buffer space used to read input intended for the engine.
   std::vector<unsigned char> input_buffer_space_;
 
   // A buffer that may be used to read input intended for the engine.
-  const asio::mutable_buffers_1 input_buffer_;
+  const asio::mutable_buffer input_buffer_;
 
   // The buffer pointing to the engine's unconsumed input.
   asio::const_buffer input_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/verify_callback.hpp b/extern/include/asio/ssl/detail/verify_callback.hpp
index 5a46b531..1c56a27d 100644
--- a/extern/include/asio/ssl/detail/verify_callback.hpp
+++ b/extern/include/asio/ssl/detail/verify_callback.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/verify_callback.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,7 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/verify_context.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/ssl/verify_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -27,8 +25,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 class verify_callback_base
 {
 public:
@@ -57,8 +53,6 @@ class verify_callback : public verify_callback_base
   VerifyCallback callback_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/detail/write_op.hpp b/extern/include/asio/ssl/detail/write_op.hpp
index e6feb1d7..1d341c09 100644
--- a/extern/include/asio/ssl/detail/write_op.hpp
+++ b/extern/include/asio/ssl/detail/write_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,10 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/detail/buffer_sequence_adapter.hpp"
-# include "asio/ssl/detail/engine.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/ssl/detail/engine.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -28,8 +26,6 @@ namespace asio {
 namespace ssl {
 namespace detail {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 template <typename ConstBufferSequence>
 class write_op
 {
@@ -62,8 +58,6 @@ class write_op
   ConstBufferSequence buffers_;
 };
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace detail
 } // namespace ssl
 } // namespace asio
diff --git a/extern/include/asio/ssl/error.hpp b/extern/include/asio/ssl/error.hpp
index 1385d2a2..6165c5cf 100644
--- a/extern/include/asio/ssl/error.hpp
+++ b/extern/include/asio/ssl/error.hpp
@@ -2,7 +2,7 @@
 // ssl/error.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/error_code.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -25,15 +26,41 @@ namespace error {
 
 enum ssl_errors
 {
+  // Error numbers are those produced by openssl.
 };
 
 extern ASIO_DECL
 const asio::error_category& get_ssl_category();
 
-static const asio::error_category& ssl_category
+static const asio::error_category&
+  ssl_category ASIO_UNUSED_VARIABLE
   = asio::error::get_ssl_category();
 
 } // namespace error
+namespace ssl {
+namespace error {
+
+enum stream_errors
+{
+#if defined(GENERATING_DOCUMENTATION)
+  /// The underlying stream closed before the ssl stream gracefully shut down.
+  stream_truncated
+#elif (OPENSSL_VERSION_NUMBER < 0x10100000L) && !defined(OPENSSL_IS_BORINGSSL)
+  stream_truncated = ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ)
+#else
+  stream_truncated = 1
+#endif
+};
+
+extern ASIO_DECL
+const asio::error_category& get_stream_category();
+
+static const asio::error_category&
+  stream_category ASIO_UNUSED_VARIABLE
+  = asio::ssl::error::get_stream_category();
+
+} // namespace error
+} // namespace ssl
 } // namespace asio
 
 #if defined(ASIO_HAS_STD_SYSTEM_ERROR)
@@ -44,6 +71,11 @@ template<> struct is_error_code_enum<asio::error::ssl_errors>
   static const bool value = true;
 };
 
+template<> struct is_error_code_enum<asio::ssl::error::stream_errors>
+{
+  static const bool value = true;
+};
+
 } // namespace std
 #endif // defined(ASIO_HAS_STD_SYSTEM_ERROR)
 
@@ -57,6 +89,17 @@ inline asio::error_code make_error_code(ssl_errors e)
 }
 
 } // namespace error
+namespace ssl {
+namespace error {
+
+inline asio::error_code make_error_code(stream_errors e)
+{
+  return asio::error_code(
+      static_cast<int>(e), get_stream_category());
+}
+
+} // namespace error
+} // namespace ssl
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
diff --git a/extern/include/asio/ssl/impl/context.hpp b/extern/include/asio/ssl/impl/context.hpp
index 34f23d30..40199c14 100644
--- a/extern/include/asio/ssl/impl/context.hpp
+++ b/extern/include/asio/ssl/impl/context.hpp
@@ -3,7 +3,7 @@
 // ~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2005-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,17 +18,13 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/detail/throw_error.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/detail/throw_error.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace ssl {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 template <typename VerifyCallback>
 void context::set_verify_callback(VerifyCallback callback)
 {
@@ -38,11 +34,12 @@ void context::set_verify_callback(VerifyCallback callback)
 }
 
 template <typename VerifyCallback>
-asio::error_code context::set_verify_callback(
+ASIO_SYNC_OP_VOID context::set_verify_callback(
     VerifyCallback callback, asio::error_code& ec)
 {
-  return do_set_verify_callback(
+  do_set_verify_callback(
       new detail::verify_callback<VerifyCallback>(callback), ec);
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 template <typename PasswordCallback>
@@ -54,15 +51,14 @@ void context::set_password_callback(PasswordCallback callback)
 }
 
 template <typename PasswordCallback>
-asio::error_code context::set_password_callback(
+ASIO_SYNC_OP_VOID context::set_password_callback(
     PasswordCallback callback, asio::error_code& ec)
 {
-  return do_set_password_callback(
+  do_set_password_callback(
       new detail::password_callback<PasswordCallback>(callback), ec);
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace ssl
 } // namespace asio
 
diff --git a/extern/include/asio/ssl/impl/context.ipp b/extern/include/asio/ssl/impl/context.ipp
index 4a66a0a0..b756fd26 100644
--- a/extern/include/asio/ssl/impl/context.ipp
+++ b/extern/include/asio/ssl/impl/context.ipp
@@ -3,7 +3,7 @@
 // ~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2005-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,21 +18,17 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include <cstring>
-# include "asio/detail/throw_error.hpp"
-# include "asio/error.hpp"
-# include "asio/ssl/context.hpp"
-# include "asio/ssl/error.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include <cstring>
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+#include "asio/ssl/context.hpp"
+#include "asio/ssl/error.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace ssl {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 struct context::bio_cleanup
 {
   BIO* p;
@@ -70,14 +66,15 @@ context::context(context::method m)
 
   switch (m)
   {
-#if defined(OPENSSL_NO_SSL2)
+    // SSL v2.
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)
   case context::sslv2:
   case context::sslv2_client:
   case context::sslv2_server:
     asio::detail::throw_error(
         asio::error::invalid_argument, "context");
     break;
-#else // defined(OPENSSL_NO_SSL2)
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)
   case context::sslv2:
     handle_ = ::SSL_CTX_new(::SSLv2_method());
     break;
@@ -87,7 +84,42 @@ context::context(context::method m)
   case context::sslv2_server:
     handle_ = ::SSL_CTX_new(::SSLv2_server_method());
     break;
-#endif // defined(OPENSSL_NO_SSL2)
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)
+
+    // SSL v3.
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+  case context::sslv3:
+    handle_ = ::SSL_CTX_new(::TLS_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);
+    }
+    break;
+  case context::sslv3_client:
+    handle_ = ::SSL_CTX_new(::TLS_client_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);
+    }
+    break;
+  case context::sslv3_server:
+    handle_ = ::SSL_CTX_new(::TLS_server_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);
+    }
+    break;
+#elif defined(OPENSSL_NO_SSL3)
+  case context::sslv3:
+  case context::sslv3_client:
+  case context::sslv3_server:
+    asio::detail::throw_error(
+        asio::error::invalid_argument, "context");
+    break;
+#else // defined(OPENSSL_NO_SSL3)
   case context::sslv3:
     handle_ = ::SSL_CTX_new(::SSLv3_method());
     break;
@@ -97,6 +129,35 @@ context::context(context::method m)
   case context::sslv3_server:
     handle_ = ::SSL_CTX_new(::SSLv3_server_method());
     break;
+#endif // defined(OPENSSL_NO_SSL3)
+
+    // TLS v1.0.
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+  case context::tlsv1:
+    handle_ = ::SSL_CTX_new(::TLS_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);
+    }
+    break;
+  case context::tlsv1_client:
+    handle_ = ::SSL_CTX_new(::TLS_client_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);
+    }
+    break;
+  case context::tlsv1_server:
+    handle_ = ::SSL_CTX_new(::TLS_server_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);
+    }
+    break;
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
   case context::tlsv1:
     handle_ = ::SSL_CTX_new(::TLSv1_method());
     break;
@@ -106,16 +167,35 @@ context::context(context::method m)
   case context::tlsv1_server:
     handle_ = ::SSL_CTX_new(::TLSv1_server_method());
     break;
-  case context::sslv23:
-    handle_ = ::SSL_CTX_new(::SSLv23_method());
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+
+    // TLS v1.1.
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+  case context::tlsv11:
+    handle_ = ::SSL_CTX_new(::TLS_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);
+    }
     break;
-  case context::sslv23_client:
-    handle_ = ::SSL_CTX_new(::SSLv23_client_method());
+  case context::tlsv11_client:
+    handle_ = ::SSL_CTX_new(::TLS_client_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);
+    }
     break;
-  case context::sslv23_server:
-    handle_ = ::SSL_CTX_new(::SSLv23_server_method());
+  case context::tlsv11_server:
+    handle_ = ::SSL_CTX_new(::TLS_server_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);
+    }
     break;
-#if defined(SSL_TXT_TLSV1_1)
+#elif defined(SSL_TXT_TLSV1_1)
   case context::tlsv11:
     handle_ = ::SSL_CTX_new(::TLSv1_1_method());
     break;
@@ -133,7 +213,34 @@ context::context(context::method m)
         asio::error::invalid_argument, "context");
     break;
 #endif // defined(SSL_TXT_TLSV1_1)
-#if defined(SSL_TXT_TLSV1_2)
+
+    // TLS v1.2.
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+  case context::tlsv12:
+    handle_ = ::SSL_CTX_new(::TLS_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);
+    }
+    break;
+  case context::tlsv12_client:
+    handle_ = ::SSL_CTX_new(::TLS_client_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);
+    }
+    break;
+  case context::tlsv12_server:
+    handle_ = ::SSL_CTX_new(::TLS_server_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);
+    }
+    break;
+#elif defined(SSL_TXT_TLSV1_1)
   case context::tlsv12:
     handle_ = ::SSL_CTX_new(::TLSv1_2_method());
     break;
@@ -143,14 +250,61 @@ context::context(context::method m)
   case context::tlsv12_server:
     handle_ = ::SSL_CTX_new(::TLSv1_2_server_method());
     break;
-#else // defined(SSL_TXT_TLSV1_2) 
+#else // defined(SSL_TXT_TLSV1_1)
   case context::tlsv12:
   case context::tlsv12_client:
   case context::tlsv12_server:
     asio::detail::throw_error(
         asio::error::invalid_argument, "context");
     break;
-#endif // defined(SSL_TXT_TLSV1_2) 
+#endif // defined(SSL_TXT_TLSV1_1)
+
+    // Any supported SSL/TLS version.
+  case context::sslv23:
+    handle_ = ::SSL_CTX_new(::SSLv23_method());
+    break;
+  case context::sslv23_client:
+    handle_ = ::SSL_CTX_new(::SSLv23_client_method());
+    break;
+  case context::sslv23_server:
+    handle_ = ::SSL_CTX_new(::SSLv23_server_method());
+    break;
+
+    // Any supported TLS version.
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+  case context::tls:
+    handle_ = ::SSL_CTX_new(::TLS_method());
+    if (handle_)
+      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
+    break;
+  case context::tls_client:
+    handle_ = ::SSL_CTX_new(::TLS_client_method());
+    if (handle_)
+      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
+    break;
+  case context::tls_server:
+    handle_ = ::SSL_CTX_new(::TLS_server_method());
+    if (handle_)
+      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
+    break;
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+  case context::tls:
+    handle_ = ::SSL_CTX_new(::SSLv23_method());
+    if (handle_)
+      SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
+    break;
+  case context::tls_client:
+    handle_ = ::SSL_CTX_new(::SSLv23_client_method());
+    if (handle_)
+      SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
+    break;
+  case context::tls_server:
+    handle_ = ::SSL_CTX_new(::SSLv23_server_method());
+    if (handle_)
+      SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
+    break;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+
   default:
     handle_ = ::SSL_CTX_new(0);
     break;
@@ -167,14 +321,6 @@ context::context(context::method m)
   set_options(no_compression);
 }
 
-context::context(asio::io_service&, context::method m)
-  : handle_(0)
-{
-  context tmp(m);
-  handle_ = tmp.handle_;
-  tmp.handle_ = 0;
-}
-
 #if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 context::context(context&& other)
 {
@@ -195,13 +341,22 @@ context::~context()
 {
   if (handle_)
   {
-    if (handle_->default_passwd_callback_userdata)
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+    void* cb_userdata = handle_->default_passwd_callback_userdata;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+    if (cb_userdata)
     {
       detail::password_callback_base* callback =
         static_cast<detail::password_callback_base*>(
-            handle_->default_passwd_callback_userdata);
+            cb_userdata);
       delete callback;
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+      ::SSL_CTX_set_default_passwd_cb_userdata(handle_, 0);
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
       handle_->default_passwd_callback_userdata = 0;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
     }
 
     if (SSL_CTX_get_app_data(handle_))
@@ -222,11 +377,6 @@ context::native_handle_type context::native_handle()
   return handle_;
 }
 
-context::impl_type context::impl()
-{
-  return handle_;
-}
-
 void context::clear_options(context::options o)
 {
   asio::error_code ec;
@@ -234,7 +384,7 @@ void context::clear_options(context::options o)
   asio::detail::throw_error(ec, "clear_options");
 }
 
-asio::error_code context::clear_options(
+ASIO_SYNC_OP_VOID context::clear_options(
     context::options o, asio::error_code& ec)
 {
 #if (OPENSSL_VERSION_NUMBER >= 0x009080DFL) \
@@ -258,7 +408,7 @@ asio::error_code context::clear_options(
   ec = asio::error::operation_not_supported;
 #endif // (OPENSSL_VERSION_NUMBER >= 0x009080DFL)
        //   && (OPENSSL_VERSION_NUMBER != 0x00909000L)
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::set_options(context::options o)
@@ -268,7 +418,7 @@ void context::set_options(context::options o)
   asio::detail::throw_error(ec, "set_options");
 }
 
-asio::error_code context::set_options(
+ASIO_SYNC_OP_VOID context::set_options(
     context::options o, asio::error_code& ec)
 {
 #if !defined(SSL_OP_NO_COMPRESSION)
@@ -285,7 +435,7 @@ asio::error_code context::set_options(
   ::SSL_CTX_set_options(handle_, o);
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::set_verify_mode(verify_mode v)
@@ -295,13 +445,13 @@ void context::set_verify_mode(verify_mode v)
   asio::detail::throw_error(ec, "set_verify_mode");
 }
 
-asio::error_code context::set_verify_mode(
+ASIO_SYNC_OP_VOID context::set_verify_mode(
     verify_mode v, asio::error_code& ec)
 {
   ::SSL_CTX_set_verify(handle_, v, ::SSL_CTX_get_verify_callback(handle_));
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::set_verify_depth(int depth)
@@ -311,13 +461,13 @@ void context::set_verify_depth(int depth)
   asio::detail::throw_error(ec, "set_verify_depth");
 }
 
-asio::error_code context::set_verify_depth(
+ASIO_SYNC_OP_VOID context::set_verify_depth(
     int depth, asio::error_code& ec)
 {
   ::SSL_CTX_set_verify_depth(handle_, depth);
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::load_verify_file(const std::string& filename)
@@ -327,7 +477,7 @@ void context::load_verify_file(const std::string& filename)
   asio::detail::throw_error(ec, "load_verify_file");
 }
 
-asio::error_code context::load_verify_file(
+ASIO_SYNC_OP_VOID context::load_verify_file(
     const std::string& filename, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -337,11 +487,11 @@ asio::error_code context::load_verify_file(
     ec = asio::error_code(
         static_cast<int>(::ERR_get_error()),
         asio::error::get_ssl_category());
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::add_certificate_authority(const const_buffer& ca)
@@ -351,7 +501,7 @@ void context::add_certificate_authority(const const_buffer& ca)
   asio::detail::throw_error(ec, "add_certificate_authority");
 }
 
-asio::error_code context::add_certificate_authority(
+ASIO_SYNC_OP_VOID context::add_certificate_authority(
     const const_buffer& ca, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -359,24 +509,27 @@ asio::error_code context::add_certificate_authority(
   bio_cleanup bio = { make_buffer_bio(ca) };
   if (bio.p)
   {
-    x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };
-    if (cert.p)
+    if (X509_STORE* store = ::SSL_CTX_get_cert_store(handle_))
     {
-      if (X509_STORE* store = ::SSL_CTX_get_cert_store(handle_))
+      for (;;)
       {
-        if (::X509_STORE_add_cert(store, cert.p) == 1)
+        x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };
+        if (!cert.p)
+          break;
+
+        if (::X509_STORE_add_cert(store, cert.p) != 1)
         {
-          ec = asio::error_code();
-          return ec;
+          ec = asio::error_code(
+              static_cast<int>(::ERR_get_error()),
+              asio::error::get_ssl_category());
+          ASIO_SYNC_OP_VOID_RETURN(ec);
         }
       }
     }
   }
 
-  ec = asio::error_code(
-      static_cast<int>(::ERR_get_error()),
-      asio::error::get_ssl_category());
-  return ec;
+  ec = asio::error_code();
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::set_default_verify_paths()
@@ -386,7 +539,7 @@ void context::set_default_verify_paths()
   asio::detail::throw_error(ec, "set_default_verify_paths");
 }
 
-asio::error_code context::set_default_verify_paths(
+ASIO_SYNC_OP_VOID context::set_default_verify_paths(
     asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -396,11 +549,11 @@ asio::error_code context::set_default_verify_paths(
     ec = asio::error_code(
         static_cast<int>(::ERR_get_error()),
         asio::error::get_ssl_category());
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::add_verify_path(const std::string& path)
@@ -410,7 +563,7 @@ void context::add_verify_path(const std::string& path)
   asio::detail::throw_error(ec, "add_verify_path");
 }
 
-asio::error_code context::add_verify_path(
+ASIO_SYNC_OP_VOID context::add_verify_path(
     const std::string& path, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -420,11 +573,11 @@ asio::error_code context::add_verify_path(
     ec = asio::error_code(
         static_cast<int>(::ERR_get_error()),
         asio::error::get_ssl_category());
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_certificate(
@@ -435,7 +588,7 @@ void context::use_certificate(
   asio::detail::throw_error(ec, "use_certificate");
 }
 
-asio::error_code context::use_certificate(
+ASIO_SYNC_OP_VOID context::use_certificate(
     const const_buffer& certificate, file_format format,
     asio::error_code& ec)
 {
@@ -444,11 +597,11 @@ asio::error_code context::use_certificate(
   if (format == context_base::asn1)
   {
     if (::SSL_CTX_use_certificate_ASN1(handle_,
-          static_cast<int>(buffer_size(certificate)),
-          buffer_cast<const unsigned char*>(certificate)) == 1)
+          static_cast<int>(certificate.size()),
+          static_cast<const unsigned char*>(certificate.data())) == 1)
     {
       ec = asio::error_code();
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
   }
   else if (format == context_base::pem)
@@ -462,7 +615,7 @@ asio::error_code context::use_certificate(
         if (::SSL_CTX_use_certificate(handle_, cert.p) == 1)
         {
           ec = asio::error_code();
-          return ec;
+          ASIO_SYNC_OP_VOID_RETURN(ec);
         }
       }
     }
@@ -470,13 +623,13 @@ asio::error_code context::use_certificate(
   else
   {
     ec = asio::error::invalid_argument;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code(
       static_cast<int>(::ERR_get_error()),
       asio::error::get_ssl_category());
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_certificate_file(
@@ -487,7 +640,7 @@ void context::use_certificate_file(
   asio::detail::throw_error(ec, "use_certificate_file");
 }
 
-asio::error_code context::use_certificate_file(
+ASIO_SYNC_OP_VOID context::use_certificate_file(
     const std::string& filename, file_format format,
     asio::error_code& ec)
 {
@@ -503,7 +656,7 @@ asio::error_code context::use_certificate_file(
   default:
     {
       ec = asio::error::invalid_argument;
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
   }
 
@@ -514,11 +667,11 @@ asio::error_code context::use_certificate_file(
     ec = asio::error_code(
         static_cast<int>(::ERR_get_error()),
         asio::error::get_ssl_category());
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_certificate_chain(const const_buffer& chain)
@@ -528,7 +681,7 @@ void context::use_certificate_chain(const const_buffer& chain)
   asio::detail::throw_error(ec, "use_certificate_chain");
 }
 
-asio::error_code context::use_certificate_chain(
+ASIO_SYNC_OP_VOID context::use_certificate_chain(
     const const_buffer& chain, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -536,15 +689,22 @@ asio::error_code context::use_certificate_chain(
   bio_cleanup bio = { make_buffer_bio(chain) };
   if (bio.p)
   {
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+    pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
+    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+    pem_password_cb* callback = handle_->default_passwd_callback;
+    void* cb_userdata = handle_->default_passwd_callback_userdata;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
     x509_cleanup cert = {
       ::PEM_read_bio_X509_AUX(bio.p, 0,
-          handle_->default_passwd_callback,
-          handle_->default_passwd_callback_userdata) };
+          callback,
+          cb_userdata) };
     if (!cert.p)
     {
       ec = asio::error_code(ERR_R_PEM_LIB,
           asio::error::get_ssl_category());
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
 
     int result = ::SSL_CTX_use_certificate(handle_, cert.p);
@@ -553,25 +713,29 @@ asio::error_code context::use_certificate_chain(
       ec = asio::error_code(
           static_cast<int>(::ERR_get_error()),
           asio::error::get_ssl_category());
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
 
+#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && !defined(LIBRESSL_VERSION_NUMBER)
+    ::SSL_CTX_clear_chain_certs(handle_);
+#else
     if (handle_->extra_certs)
     {
       ::sk_X509_pop_free(handle_->extra_certs, X509_free);
       handle_->extra_certs = 0;
     }
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10002000L)
 
     while (X509* cacert = ::PEM_read_bio_X509(bio.p, 0,
-          handle_->default_passwd_callback,
-          handle_->default_passwd_callback_userdata))
+          callback,
+          cb_userdata))
     {
       if (!::SSL_CTX_add_extra_chain_cert(handle_, cacert))
       {
         ec = asio::error_code(
             static_cast<int>(::ERR_get_error()),
             asio::error::get_ssl_category());
-        return ec;
+        ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
   
@@ -581,14 +745,14 @@ asio::error_code context::use_certificate_chain(
     {
       ::ERR_clear_error();
       ec = asio::error_code();
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
   }
 
   ec = asio::error_code(
       static_cast<int>(::ERR_get_error()),
       asio::error::get_ssl_category());
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_certificate_chain_file(const std::string& filename)
@@ -598,7 +762,7 @@ void context::use_certificate_chain_file(const std::string& filename)
   asio::detail::throw_error(ec, "use_certificate_chain_file");
 }
 
-asio::error_code context::use_certificate_chain_file(
+ASIO_SYNC_OP_VOID context::use_certificate_chain_file(
     const std::string& filename, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -608,11 +772,11 @@ asio::error_code context::use_certificate_chain_file(
     ec = asio::error_code(
         static_cast<int>(::ERR_get_error()),
         asio::error::get_ssl_category());
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_private_key(
@@ -623,12 +787,20 @@ void context::use_private_key(
   asio::detail::throw_error(ec, "use_private_key");
 }
 
-asio::error_code context::use_private_key(
+ASIO_SYNC_OP_VOID context::use_private_key(
     const const_buffer& private_key, context::file_format format,
     asio::error_code& ec)
 {
   ::ERR_clear_error();
 
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+    pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
+    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+    pem_password_cb* callback = handle_->default_passwd_callback;
+    void* cb_userdata = handle_->default_passwd_callback_userdata;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+
   bio_cleanup bio = { make_buffer_bio(private_key) };
   if (bio.p)
   {
@@ -640,13 +812,13 @@ asio::error_code context::use_private_key(
       break;
     case context_base::pem:
       evp_private_key.p = ::PEM_read_bio_PrivateKey(
-          bio.p, 0, handle_->default_passwd_callback,
-          handle_->default_passwd_callback_userdata);
+          bio.p, 0, callback,
+          cb_userdata);
       break;
     default:
       {
         ec = asio::error::invalid_argument;
-        return ec;
+        ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
 
@@ -655,7 +827,7 @@ asio::error_code context::use_private_key(
       if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)
       {
         ec = asio::error_code();
-        return ec;
+        ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
   }
@@ -663,7 +835,7 @@ asio::error_code context::use_private_key(
   ec = asio::error_code(
       static_cast<int>(::ERR_get_error()),
       asio::error::get_ssl_category());
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_private_key_file(
@@ -682,12 +854,20 @@ void context::use_rsa_private_key(
   asio::detail::throw_error(ec, "use_rsa_private_key");
 }
 
-asio::error_code context::use_rsa_private_key(
+ASIO_SYNC_OP_VOID context::use_rsa_private_key(
     const const_buffer& private_key, context::file_format format,
     asio::error_code& ec)
 {
   ::ERR_clear_error();
 
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+    pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
+    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+    pem_password_cb* callback = handle_->default_passwd_callback;
+    void* cb_userdata = handle_->default_passwd_callback_userdata;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+
   bio_cleanup bio = { make_buffer_bio(private_key) };
   if (bio.p)
   {
@@ -699,13 +879,13 @@ asio::error_code context::use_rsa_private_key(
       break;
     case context_base::pem:
       rsa_private_key.p = ::PEM_read_bio_RSAPrivateKey(
-          bio.p, 0, handle_->default_passwd_callback,
-          handle_->default_passwd_callback_userdata);
+          bio.p, 0, callback,
+          cb_userdata);
       break;
     default:
       {
         ec = asio::error::invalid_argument;
-        return ec;
+        ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
 
@@ -714,7 +894,7 @@ asio::error_code context::use_rsa_private_key(
       if (::SSL_CTX_use_RSAPrivateKey(handle_, rsa_private_key.p) == 1)
       {
         ec = asio::error_code();
-        return ec;
+        ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
   }
@@ -722,10 +902,10 @@ asio::error_code context::use_rsa_private_key(
   ec = asio::error_code(
       static_cast<int>(::ERR_get_error()),
       asio::error::get_ssl_category());
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code context::use_private_key_file(
+ASIO_SYNC_OP_VOID context::use_private_key_file(
     const std::string& filename, context::file_format format,
     asio::error_code& ec)
 {
@@ -741,7 +921,7 @@ asio::error_code context::use_private_key_file(
   default:
     {
       ec = asio::error::invalid_argument;
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
   }
 
@@ -752,11 +932,11 @@ asio::error_code context::use_private_key_file(
     ec = asio::error_code(
         static_cast<int>(::ERR_get_error()),
         asio::error::get_ssl_category());
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_rsa_private_key_file(
@@ -767,7 +947,7 @@ void context::use_rsa_private_key_file(
   asio::detail::throw_error(ec, "use_rsa_private_key_file");
 }
 
-asio::error_code context::use_rsa_private_key_file(
+ASIO_SYNC_OP_VOID context::use_rsa_private_key_file(
     const std::string& filename, context::file_format format,
     asio::error_code& ec)
 {
@@ -783,7 +963,7 @@ asio::error_code context::use_rsa_private_key_file(
   default:
     {
       ec = asio::error::invalid_argument;
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
   }
 
@@ -795,11 +975,11 @@ asio::error_code context::use_rsa_private_key_file(
     ec = asio::error_code(
         static_cast<int>(::ERR_get_error()),
         asio::error::get_ssl_category());
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_tmp_dh(const const_buffer& dh)
@@ -809,7 +989,7 @@ void context::use_tmp_dh(const const_buffer& dh)
   asio::detail::throw_error(ec, "use_tmp_dh");
 }
 
-asio::error_code context::use_tmp_dh(
+ASIO_SYNC_OP_VOID context::use_tmp_dh(
     const const_buffer& dh, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -823,7 +1003,7 @@ asio::error_code context::use_tmp_dh(
   ec = asio::error_code(
       static_cast<int>(::ERR_get_error()),
       asio::error::get_ssl_category());
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 void context::use_tmp_dh_file(const std::string& filename)
@@ -833,7 +1013,7 @@ void context::use_tmp_dh_file(const std::string& filename)
   asio::detail::throw_error(ec, "use_tmp_dh_file");
 }
 
-asio::error_code context::use_tmp_dh_file(
+ASIO_SYNC_OP_VOID context::use_tmp_dh_file(
     const std::string& filename, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -847,10 +1027,10 @@ asio::error_code context::use_tmp_dh_file(
   ec = asio::error_code(
       static_cast<int>(::ERR_get_error()),
       asio::error::get_ssl_category());
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code context::do_use_tmp_dh(
+ASIO_SYNC_OP_VOID context::do_use_tmp_dh(
     BIO* bio, asio::error_code& ec)
 {
   ::ERR_clear_error();
@@ -861,17 +1041,17 @@ asio::error_code context::do_use_tmp_dh(
     if (::SSL_CTX_set_tmp_dh(handle_, dh.p) == 1)
     {
       ec = asio::error_code();
-      return ec;
+      ASIO_SYNC_OP_VOID_RETURN(ec);
     }
   }
 
   ec = asio::error_code(
       static_cast<int>(::ERR_get_error()),
       asio::error::get_ssl_category());
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
-asio::error_code context::do_set_verify_callback(
+ASIO_SYNC_OP_VOID context::do_set_verify_callback(
     detail::verify_callback_base* callback, asio::error_code& ec)
 {
   if (SSL_CTX_get_app_data(handle_))
@@ -887,7 +1067,7 @@ asio::error_code context::do_set_verify_callback(
       &context::verify_callback_function);
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 int context::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
@@ -916,19 +1096,25 @@ int context::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
   return 0;
 }
 
-asio::error_code context::do_set_password_callback(
+ASIO_SYNC_OP_VOID context::do_set_password_callback(
     detail::password_callback_base* callback, asio::error_code& ec)
 {
-  if (handle_->default_passwd_callback_userdata)
-    delete static_cast<detail::password_callback_base*>(
-        handle_->default_passwd_callback_userdata);
-
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+  void* old_callback = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
+  ::SSL_CTX_set_default_passwd_cb_userdata(handle_, callback);
+#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+  void* old_callback = handle_->default_passwd_callback_userdata;
   handle_->default_passwd_callback_userdata = callback;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+
+  if (old_callback)
+    delete static_cast<detail::password_callback_base*>(
+        old_callback);
 
   SSL_CTX_set_default_passwd_cb(handle_, &context::password_callback_function);
 
   ec = asio::error_code();
-  return ec;
+  ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
 int context::password_callback_function(
@@ -948,7 +1134,8 @@ int context::password_callback_function(
     strcpy_s(buf, size, passwd.c_str());
 #else // defined(ASIO_HAS_SECURE_RTL)
     *buf = '\0';
-    strncat(buf, passwd.c_str(), size);
+    if (size > 0)
+      strncat(buf, passwd.c_str(), size - 1);
 #endif // defined(ASIO_HAS_SECURE_RTL)
 
     return static_cast<int>(strlen(buf));
@@ -960,12 +1147,10 @@ int context::password_callback_function(
 BIO* context::make_buffer_bio(const const_buffer& b)
 {
   return ::BIO_new_mem_buf(
-      const_cast<void*>(buffer_cast<const void*>(b)),
-      static_cast<int>(buffer_size(b)));
+      const_cast<void*>(b.data()),
+      static_cast<int>(b.size()));
 }
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace ssl
 } // namespace asio
 
diff --git a/extern/include/asio/ssl/impl/error.ipp b/extern/include/asio/ssl/impl/error.ipp
index 9e76039a..98e8c91b 100644
--- a/extern/include/asio/ssl/impl/error.ipp
+++ b/extern/include/asio/ssl/impl/error.ipp
@@ -2,7 +2,7 @@
 // ssl/impl/error.ipp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,7 +23,6 @@
 
 namespace asio {
 namespace error {
-
 namespace detail {
 
 class ssl_category : public asio::error_category
@@ -50,6 +49,50 @@ const asio::error_category& get_ssl_category()
 }
 
 } // namespace error
+namespace ssl {
+namespace error {
+
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L) && !defined(OPENSSL_IS_BORINGSSL)
+
+const asio::error_category& get_stream_category()
+{
+  return asio::error::get_ssl_category();
+}
+
+#else
+
+namespace detail {
+
+class stream_category : public asio::error_category
+{
+public:
+  const char* name() const ASIO_ERROR_CATEGORY_NOEXCEPT
+  {
+    return "asio.ssl.stream";
+  }
+
+  std::string message(int value) const
+  {
+    switch (value)
+    {
+    case stream_truncated: return "stream truncated";
+    default: return "asio.ssl.stream error";
+    }
+  }
+};
+
+} // namespace detail
+
+const asio::error_category& get_stream_category()
+{
+  static detail::stream_category instance;
+  return instance;
+}
+
+#endif
+
+} // namespace error
+} // namespace ssl
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
diff --git a/extern/include/asio/ssl/impl/rfc2818_verification.ipp b/extern/include/asio/ssl/impl/rfc2818_verification.ipp
index 81866df7..577e4a12 100644
--- a/extern/include/asio/ssl/impl/rfc2818_verification.ipp
+++ b/extern/include/asio/ssl/impl/rfc2818_verification.ipp
@@ -2,7 +2,7 @@
 // ssl/impl/rfc2818_verification.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,21 +17,17 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include <cctype>
-# include <cstring>
-# include "asio/ip/address.hpp"
-# include "asio/ssl/rfc2818_verification.hpp"
-# include "asio/ssl/detail/openssl_types.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include <cctype>
+#include <cstring>
+#include "asio/ip/address.hpp"
+#include "asio/ssl/rfc2818_verification.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace ssl {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 bool rfc2818_verification::operator()(
     bool preverified, verify_context& ctx) const
 {
@@ -49,7 +45,7 @@ bool rfc2818_verification::operator()(
   // Try converting the host name to an address. If it is an address then we
   // need to look for an IP address in the certificate rather than a host name.
   asio::error_code ec;
-  ip::address address = ip::address::from_string(host_, ec);
+  ip::address address = ip::make_address(host_, ec);
   bool is_address = !ec;
 
   X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
@@ -156,8 +152,6 @@ bool rfc2818_verification::match_pattern(const char* pattern,
   return p == p_end && !*h;
 }
 
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace ssl
 } // namespace asio
 
diff --git a/extern/include/asio/ssl/impl/src.hpp b/extern/include/asio/ssl/impl/src.hpp
index 8db35ce1..9a1b038a 100644
--- a/extern/include/asio/ssl/impl/src.hpp
+++ b/extern/include/asio/ssl/impl/src.hpp
@@ -2,7 +2,7 @@
 // impl/ssl/src.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ssl/old/basic_context.hpp b/extern/include/asio/ssl/old/basic_context.hpp
deleted file mode 100644
index 60feca9b..00000000
--- a/extern/include/asio/ssl/old/basic_context.hpp
+++ /dev/null
@@ -1,434 +0,0 @@
-//
-// ssl/old/basic_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_OLD_BASIC_CONTEXT_HPP
-#define ASIO_SSL_OLD_BASIC_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include <boost/noncopyable.hpp>
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/ssl/context_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace old {
-
-/// SSL context.
-template <typename Service>
-class basic_context
-  : public context_base,
-    private boost::noncopyable
-{
-public:
-  /// The type of the service that will be used to provide context operations.
-  typedef Service service_type;
-
-  /// The native implementation type of the SSL context.
-  typedef typename service_type::impl_type impl_type;
-
-  /// Constructor.
-  basic_context(asio::io_service& io_service, method m)
-    : service_(asio::use_service<Service>(io_service)),
-      impl_(service_.null())
-  {
-    service_.create(impl_, m);
-  }
-
-  /// Destructor.
-  ~basic_context()
-  {
-    service_.destroy(impl_);
-  }
-
-  /// Get the underlying implementation in the native type.
-  /**
-   * This function may be used to obtain the underlying implementation of the
-   * context. This is intended to allow access to context functionality that is
-   * not otherwise provided.
-   */
-  impl_type impl()
-  {
-    return impl_;
-  }
-
-  /// Set options on the context.
-  /**
-   * This function may be used to configure the SSL options used by the context.
-   *
-   * @param o A bitmask of options. The available option values are defined in
-   * the context_base class. The options are bitwise-ored with any existing
-   * value for the options.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void set_options(options o)
-  {
-    asio::error_code ec;
-    service_.set_options(impl_, o, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Set options on the context.
-  /**
-   * This function may be used to configure the SSL options used by the context.
-   *
-   * @param o A bitmask of options. The available option values are defined in
-   * the context_base class. The options are bitwise-ored with any existing
-   * value for the options.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code set_options(options o,
-      asio::error_code& ec)
-  {
-    return service_.set_options(impl_, o, ec);
-  }
-
-  /// Set the peer verification mode.
-  /**
-   * This function may be used to configure the peer verification mode used by
-   * the context.
-   *
-   * @param v A bitmask of peer verification modes. The available verify_mode
-   * values are defined in the context_base class.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void set_verify_mode(verify_mode v)
-  {
-    asio::error_code ec;
-    service_.set_verify_mode(impl_, v, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Set the peer verification mode.
-  /**
-   * This function may be used to configure the peer verification mode used by
-   * the context.
-   *
-   * @param v A bitmask of peer verification modes. The available verify_mode
-   * values are defined in the context_base class.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code set_verify_mode(verify_mode v,
-      asio::error_code& ec)
-  {
-    return service_.set_verify_mode(impl_, v, ec);
-  }
-
-  /// Load a certification authority file for performing verification.
-  /**
-   * This function is used to load one or more trusted certification authorities
-   * from a file.
-   *
-   * @param filename The name of a file containing certification authority
-   * certificates in PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void load_verify_file(const std::string& filename)
-  {
-    asio::error_code ec;
-    service_.load_verify_file(impl_, filename, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Load a certification authority file for performing verification.
-  /**
-   * This function is used to load the certificates for one or more trusted
-   * certification authorities from a file.
-   *
-   * @param filename The name of a file containing certification authority
-   * certificates in PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code load_verify_file(const std::string& filename,
-      asio::error_code& ec)
-  {
-    return service_.load_verify_file(impl_, filename, ec);
-  }
-
-  /// Add a directory containing certificate authority files to be used for
-  /// performing verification.
-  /**
-   * This function is used to specify the name of a directory containing
-   * certification authority certificates. Each file in the directory must
-   * contain a single certificate. The files must be named using the subject
-   * name's hash and an extension of ".0".
-   *
-   * @param path The name of a directory containing the certificates.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void add_verify_path(const std::string& path)
-  {
-    asio::error_code ec;
-    service_.add_verify_path(impl_, path, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Add a directory containing certificate authority files to be used for
-  /// performing verification.
-  /**
-   * This function is used to specify the name of a directory containing
-   * certification authority certificates. Each file in the directory must
-   * contain a single certificate. The files must be named using the subject
-   * name's hash and an extension of ".0".
-   *
-   * @param path The name of a directory containing the certificates.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code add_verify_path(const std::string& path,
-      asio::error_code& ec)
-  {
-    return service_.add_verify_path(impl_, path, ec);
-  }
-
-  /// Use a certificate from a file.
-  /**
-   * This function is used to load a certificate into the context from a file.
-   *
-   * @param filename The name of the file containing the certificate.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void use_certificate_file(const std::string& filename, file_format format)
-  {
-    asio::error_code ec;
-    service_.use_certificate_file(impl_, filename, format, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Use a certificate from a file.
-  /**
-   * This function is used to load a certificate into the context from a file.
-   *
-   * @param filename The name of the file containing the certificate.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code use_certificate_file(const std::string& filename,
-      file_format format, asio::error_code& ec)
-  {
-    return service_.use_certificate_file(impl_, filename, format, ec);
-  }
-
-  /// Use a certificate chain from a file.
-  /**
-   * This function is used to load a certificate chain into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the certificate. The file
-   * must use the PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void use_certificate_chain_file(const std::string& filename)
-  {
-    asio::error_code ec;
-    service_.use_certificate_chain_file(impl_, filename, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Use a certificate chain from a file.
-  /**
-   * This function is used to load a certificate chain into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the certificate. The file
-   * must use the PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code use_certificate_chain_file(
-      const std::string& filename, asio::error_code& ec)
-  {
-    return service_.use_certificate_chain_file(impl_, filename, ec);
-  }
-
-  /// Use a private key from a file.
-  /**
-   * This function is used to load a private key into the context from a file.
-   *
-   * @param filename The name of the file containing the private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void use_private_key_file(const std::string& filename, file_format format)
-  {
-    asio::error_code ec;
-    service_.use_private_key_file(impl_, filename, format, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Use a private key from a file.
-  /**
-   * This function is used to load a private key into the context from a file.
-   *
-   * @param filename The name of the file containing the private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code use_private_key_file(const std::string& filename,
-      file_format format, asio::error_code& ec)
-  {
-    return service_.use_private_key_file(impl_, filename, format, ec);
-  }
-
-  /// Use an RSA private key from a file.
-  /**
-   * This function is used to load an RSA private key into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the RSA private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void use_rsa_private_key_file(const std::string& filename, file_format format)
-  {
-    asio::error_code ec;
-    service_.use_rsa_private_key_file(impl_, filename, format, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Use an RSA private key from a file.
-  /**
-   * This function is used to load an RSA private key into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the RSA private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code use_rsa_private_key_file(
-      const std::string& filename, file_format format,
-      asio::error_code& ec)
-  {
-    return service_.use_rsa_private_key_file(impl_, filename, format, ec);
-  }
-
-  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
-  /**
-   * This function is used to load Diffie-Hellman parameters into the context
-   * from a file.
-   *
-   * @param filename The name of the file containing the Diffie-Hellman
-   * parameters. The file must use the PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void use_tmp_dh_file(const std::string& filename)
-  {
-    asio::error_code ec;
-    service_.use_tmp_dh_file(impl_, filename, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
-  /**
-   * This function is used to load Diffie-Hellman parameters into the context
-   * from a file.
-   *
-   * @param filename The name of the file containing the Diffie-Hellman
-   * parameters. The file must use the PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code use_tmp_dh_file(const std::string& filename,
-      asio::error_code& ec)
-  {
-    return service_.use_tmp_dh_file(impl_, filename, ec);
-  }
-
-  /// Set the password callback.
-  /**
-   * This function is used to specify a callback function to obtain password
-   * information about an encrypted key in PEM format.
-   *
-   * @param callback The function object to be used for obtaining the password.
-   * The function signature of the handler must be:
-   * @code std::string password_callback(
-   *   std::size_t max_length,  // The maximum size for a password.
-   *   password_purpose purpose // Whether password is for reading or writing.
-   * ); @endcode
-   * The return value of the callback is a string containing the password.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename PasswordCallback>
-  void set_password_callback(PasswordCallback callback)
-  {
-    asio::error_code ec;
-    service_.set_password_callback(impl_, callback, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Set the password callback.
-  /**
-   * This function is used to specify a callback function to obtain password
-   * information about an encrypted key in PEM format.
-   *
-   * @param callback The function object to be used for obtaining the password.
-   * The function signature of the handler must be:
-   * @code std::string password_callback(
-   *   std::size_t max_length,  // The maximum size for a password.
-   *   password_purpose purpose // Whether password is for reading or writing.
-   * ); @endcode
-   * The return value of the callback is a string containing the password.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  template <typename PasswordCallback>
-  asio::error_code set_password_callback(PasswordCallback callback,
-      asio::error_code& ec)
-  {
-    return service_.set_password_callback(impl_, callback, ec);
-  }
-
-private:
-  /// The backend service implementation.
-  service_type& service_;
-
-  /// The underlying native implementation.
-  impl_type impl_;
-};
-
-} // namespace old
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_OLD_BASIC_CONTEXT_HPP
diff --git a/extern/include/asio/ssl/old/context_service.hpp b/extern/include/asio/ssl/old/context_service.hpp
deleted file mode 100644
index 9b60aeb1..00000000
--- a/extern/include/asio/ssl/old/context_service.hpp
+++ /dev/null
@@ -1,174 +0,0 @@
-//
-// ssl/old/context_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_OLD_CONTEXT_SERVICE_HPP
-#define ASIO_SSL_OLD_CONTEXT_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include <boost/noncopyable.hpp>
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/ssl/context_base.hpp"
-#include "asio/ssl/old/detail/openssl_context_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace old {
-
-/// Default service implementation for a context.
-class context_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
-#else
-  : public asio::detail::service_base<context_service>
-#endif
-{
-private:
-  // The type of the platform-specific implementation.
-  typedef old::detail::openssl_context_service service_impl_type;
-
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static asio::io_service::id id;
-#endif
-
-  /// The type of the context.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined impl_type;
-#else
-  typedef service_impl_type::impl_type impl_type;
-#endif
-
-  /// Constructor.
-  explicit context_service(asio::io_service& io_service)
-    : asio::detail::service_base<context_service>(io_service),
-      service_impl_(asio::use_service<service_impl_type>(io_service))
-  {
-  }
-
-  /// Return a null context implementation.
-  impl_type null() const
-  {
-    return service_impl_.null();
-  }
-
-  /// Create a new context implementation.
-  void create(impl_type& impl, context_base::method m)
-  {
-    service_impl_.create(impl, m);
-  }
-
-  /// Destroy a context implementation.
-  void destroy(impl_type& impl)
-  {
-    service_impl_.destroy(impl);
-  }
-
-  /// Set options on the context.
-  asio::error_code set_options(impl_type& impl,
-      context_base::options o, asio::error_code& ec)
-  {
-    return service_impl_.set_options(impl, o, ec);
-  }
-
-  /// Set peer verification mode.
-  asio::error_code set_verify_mode(impl_type& impl,
-      context_base::verify_mode v, asio::error_code& ec)
-  {
-    return service_impl_.set_verify_mode(impl, v, ec);
-  }
-
-  /// Load a certification authority file for performing verification.
-  asio::error_code load_verify_file(impl_type& impl,
-      const std::string& filename, asio::error_code& ec)
-  {
-    return service_impl_.load_verify_file(impl, filename, ec);
-  }
-
-  /// Add a directory containing certification authority files to be used for
-  /// performing verification.
-  asio::error_code add_verify_path(impl_type& impl,
-      const std::string& path, asio::error_code& ec)
-  {
-    return service_impl_.add_verify_path(impl, path, ec);
-  }
-
-  /// Use a certificate from a file.
-  asio::error_code use_certificate_file(impl_type& impl,
-      const std::string& filename, context_base::file_format format,
-      asio::error_code& ec)
-  {
-    return service_impl_.use_certificate_file(impl, filename, format, ec);
-  }
-
-  /// Use a certificate chain from a file.
-  asio::error_code use_certificate_chain_file(impl_type& impl,
-      const std::string& filename, asio::error_code& ec)
-  {
-    return service_impl_.use_certificate_chain_file(impl, filename, ec);
-  }
-
-  /// Use a private key from a file.
-  asio::error_code use_private_key_file(impl_type& impl,
-      const std::string& filename, context_base::file_format format,
-      asio::error_code& ec)
-  {
-    return service_impl_.use_private_key_file(impl, filename, format, ec);
-  }
-
-  /// Use an RSA private key from a file.
-  asio::error_code use_rsa_private_key_file(impl_type& impl,
-      const std::string& filename, context_base::file_format format,
-      asio::error_code& ec)
-  {
-    return service_impl_.use_rsa_private_key_file(impl, filename, format, ec);
-  }
-
-  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
-  asio::error_code use_tmp_dh_file(impl_type& impl,
-      const std::string& filename, asio::error_code& ec)
-  {
-    return service_impl_.use_tmp_dh_file(impl, filename, ec);
-  }
-
-  /// Set the password callback.
-  template <typename PasswordCallback>
-  asio::error_code set_password_callback(impl_type& impl,
-      PasswordCallback callback, asio::error_code& ec)
-  {
-    return service_impl_.set_password_callback(impl, callback, ec);
-  }
-
-private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-  }
-
-  // The service that provides the platform-specific implementation.
-  service_impl_type& service_impl_;
-};
-
-} // namespace old
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_OLD_CONTEXT_SERVICE_HPP
diff --git a/extern/include/asio/ssl/old/detail/openssl_context_service.hpp b/extern/include/asio/ssl/old/detail/openssl_context_service.hpp
deleted file mode 100644
index 02abd0c6..00000000
--- a/extern/include/asio/ssl/old/detail/openssl_context_service.hpp
+++ /dev/null
@@ -1,386 +0,0 @@
-//
-// ssl/old/detail/openssl_context_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_OLD_DETAIL_OPENSSL_CONTEXT_SERVICE_HPP
-#define ASIO_SSL_OLD_DETAIL_OPENSSL_CONTEXT_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstring>
-#include <string>
-#include <boost/function.hpp>
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/ssl/context_base.hpp"
-#include "asio/ssl/detail/openssl_init.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace old {
-namespace detail {
-
-class openssl_context_service
-  : public asio::detail::service_base<openssl_context_service>
-{
-public:
-  // The native type of the context.
-  typedef ::SSL_CTX* impl_type;
-
-  // The type for the password callback function object.
-  typedef boost::function<std::string(std::size_t,
-      context_base::password_purpose)> password_callback_type;
-
-  // Constructor.
-  openssl_context_service(asio::io_service& io_service)
-    : asio::detail::service_base<openssl_context_service>(io_service)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-  }
-
-  // Return a null context implementation.
-  static impl_type null()
-  {
-    return 0;
-  }
-
-  // Create a new context implementation.
-  void create(impl_type& impl, context_base::method m)
-  {
-    switch (m)
-    {
-#if defined(OPENSSL_NO_SSL2)
-    case context_base::sslv2:
-    case context_base::sslv2_client:
-    case context_base::sslv2_server:
-      asio::detail::throw_error(asio::error::invalid_argument);
-      break;
-#else // defined(OPENSSL_NO_SSL2)
-    case context_base::sslv2:
-      impl = ::SSL_CTX_new(::SSLv2_method());
-      break;
-    case context_base::sslv2_client:
-      impl = ::SSL_CTX_new(::SSLv2_client_method());
-      break;
-    case context_base::sslv2_server:
-      impl = ::SSL_CTX_new(::SSLv2_server_method());
-      break;
-#endif // defined(OPENSSL_NO_SSL2)
-    case context_base::sslv3:
-      impl = ::SSL_CTX_new(::SSLv3_method());
-      break;
-    case context_base::sslv3_client:
-      impl = ::SSL_CTX_new(::SSLv3_client_method());
-      break;
-    case context_base::sslv3_server:
-      impl = ::SSL_CTX_new(::SSLv3_server_method());
-      break;
-    case context_base::tlsv1:
-      impl = ::SSL_CTX_new(::TLSv1_method());
-      break;
-    case context_base::tlsv1_client:
-      impl = ::SSL_CTX_new(::TLSv1_client_method());
-      break;
-    case context_base::tlsv1_server:
-      impl = ::SSL_CTX_new(::TLSv1_server_method());
-      break;
-    case context_base::sslv23:
-      impl = ::SSL_CTX_new(::SSLv23_method());
-      break;
-    case context_base::sslv23_client:
-      impl = ::SSL_CTX_new(::SSLv23_client_method());
-      break;
-    case context_base::sslv23_server:
-      impl = ::SSL_CTX_new(::SSLv23_server_method());
-      break;
-    default:
-      impl = ::SSL_CTX_new(0);
-      break;
-    }
-  }
-
-  // Destroy a context implementation.
-  void destroy(impl_type& impl)
-  {
-    if (impl != null())
-    {
-      if (impl->default_passwd_callback_userdata)
-      {
-        password_callback_type* callback =
-          static_cast<password_callback_type*>(
-              impl->default_passwd_callback_userdata);
-        delete callback;
-        impl->default_passwd_callback_userdata = 0;
-      }
-
-      ::SSL_CTX_free(impl);
-      impl = null();
-    }
-  }
-
-  // Set options on the context.
-  asio::error_code set_options(impl_type& impl,
-      context_base::options o, asio::error_code& ec)
-  {
-    ::SSL_CTX_set_options(impl, o);
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Set peer verification mode.
-  asio::error_code set_verify_mode(impl_type& impl,
-      context_base::verify_mode v, asio::error_code& ec)
-  {
-    ::SSL_CTX_set_verify(impl, v, 0);
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Load a certification authority file for performing verification.
-  asio::error_code load_verify_file(impl_type& impl,
-      const std::string& filename, asio::error_code& ec)
-  {
-    if (::SSL_CTX_load_verify_locations(impl, filename.c_str(), 0) != 1)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Add a directory containing certification authority files to be used for
-  // performing verification.
-  asio::error_code add_verify_path(impl_type& impl,
-      const std::string& path, asio::error_code& ec)
-  {
-    if (::SSL_CTX_load_verify_locations(impl, 0, path.c_str()) != 1)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Use a certificate from a file.
-  asio::error_code use_certificate_file(impl_type& impl,
-      const std::string& filename, context_base::file_format format,
-      asio::error_code& ec)
-  {
-    int file_type;
-    switch (format)
-    {
-    case context_base::asn1:
-      file_type = SSL_FILETYPE_ASN1;
-      break;
-    case context_base::pem:
-      file_type = SSL_FILETYPE_PEM;
-      break;
-    default:
-      {
-        ec = asio::error::invalid_argument;
-        return ec;
-      }
-    }
-
-    if (::SSL_CTX_use_certificate_file(impl, filename.c_str(), file_type) != 1)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Use a certificate chain from a file.
-  asio::error_code use_certificate_chain_file(impl_type& impl,
-      const std::string& filename, asio::error_code& ec)
-  {
-    if (::SSL_CTX_use_certificate_chain_file(impl, filename.c_str()) != 1)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Use a private key from a file.
-  asio::error_code use_private_key_file(impl_type& impl,
-      const std::string& filename, context_base::file_format format,
-      asio::error_code& ec)
-  {
-    int file_type;
-    switch (format)
-    {
-    case context_base::asn1:
-      file_type = SSL_FILETYPE_ASN1;
-      break;
-    case context_base::pem:
-      file_type = SSL_FILETYPE_PEM;
-      break;
-    default:
-      {
-        ec = asio::error::invalid_argument;
-        return ec;
-      }
-    }
-
-    if (::SSL_CTX_use_PrivateKey_file(impl, filename.c_str(), file_type) != 1)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Use an RSA private key from a file.
-  asio::error_code use_rsa_private_key_file(impl_type& impl,
-      const std::string& filename, context_base::file_format format,
-      asio::error_code& ec)
-  {
-    int file_type;
-    switch (format)
-    {
-    case context_base::asn1:
-      file_type = SSL_FILETYPE_ASN1;
-      break;
-    case context_base::pem:
-      file_type = SSL_FILETYPE_PEM;
-      break;
-    default:
-      {
-        ec = asio::error::invalid_argument;
-        return ec;
-      }
-    }
-
-    if (::SSL_CTX_use_RSAPrivateKey_file(
-          impl, filename.c_str(), file_type) != 1)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Use the specified file to obtain the temporary Diffie-Hellman parameters.
-  asio::error_code use_tmp_dh_file(impl_type& impl,
-      const std::string& filename, asio::error_code& ec)
-  {
-    ::BIO* bio = ::BIO_new_file(filename.c_str(), "r");
-    if (!bio)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ::DH* dh = ::PEM_read_bio_DHparams(bio, 0, 0, 0);
-    if (!dh)
-    {
-      ::BIO_free(bio);
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ::BIO_free(bio);
-    int result = ::SSL_CTX_set_tmp_dh(impl, dh);
-    ::DH_free(dh);
-    if (result != 1)
-    {
-      ec = asio::error::invalid_argument;
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  static int password_callback(char* buf, int size, int purpose, void* data)
-  {
-    using namespace std; // For strncat and strlen.
-
-    if (data)
-    {
-      password_callback_type* callback =
-        static_cast<password_callback_type*>(data);
-      std::string passwd = (*callback)(static_cast<std::size_t>(size),
-          purpose ? context_base::for_writing : context_base::for_reading);
-      *buf = '\0';
-      strncat(buf, passwd.c_str(), size);
-      return strlen(buf);
-    }
-
-    return 0;
-  }
-
-  // Set the password callback.
-  template <typename Password_Callback>
-  asio::error_code set_password_callback(impl_type& impl,
-      Password_Callback callback, asio::error_code& ec)
-  {
-    // Allocate callback function object if not already present.
-    if (impl->default_passwd_callback_userdata)
-    {
-      password_callback_type* callback_function =
-        static_cast<password_callback_type*>(
-            impl->default_passwd_callback_userdata);
-      *callback_function = callback;
-    }
-    else
-    {
-      password_callback_type* callback_function =
-        new password_callback_type(callback);
-      impl->default_passwd_callback_userdata = callback_function;
-    }
-
-    // Set the password callback.
-    SSL_CTX_set_default_passwd_cb(impl,
-        &openssl_context_service::password_callback);
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-private:
-  // Ensure openssl is initialised.
-  asio::ssl::detail::openssl_init<> init_;
-};
-
-} // namespace detail
-} // namespace old
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_OLD_DETAIL_OPENSSL_CONTEXT_SERVICE_HPP
diff --git a/extern/include/asio/ssl/old/detail/openssl_operation.hpp b/extern/include/asio/ssl/old/detail/openssl_operation.hpp
deleted file mode 100644
index 9ea9c946..00000000
--- a/extern/include/asio/ssl/old/detail/openssl_operation.hpp
+++ /dev/null
@@ -1,524 +0,0 @@
-//
-// ssl/old/detail/openssl_operation.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_OLD_DETAIL_OPENSSL_OPERATION_HPP
-#define ASIO_SSL_OLD_DETAIL_OPENSSL_OPERATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include "asio/buffer.hpp"
-#include "asio/detail/assert.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/placeholders.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-#include "asio/ssl/error.hpp"
-#include "asio/strand.hpp"
-#include "asio/system_error.hpp"
-#include "asio/write.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace old {
-namespace detail {
-
-typedef boost::function<int (::SSL*)> ssl_primitive_func; 
-typedef boost::function<void (const asio::error_code&, int)>
-  user_handler_func;
-
-// Network send_/recv buffer implementation
-//
-//
-class net_buffer
-{
-  static const int  NET_BUF_SIZE = 16*1024 + 256; // SSL record size + spare
-
-  unsigned char buf_[NET_BUF_SIZE];
-  unsigned char* data_start_;
-  unsigned char* data_end_;
-
-public:
-  net_buffer()
-  {
-    data_start_ = data_end_ = buf_;
-  }
-  unsigned char* get_unused_start() { return data_end_; }
-  unsigned char* get_data_start() { return data_start_; }
-  size_t get_unused_len() { return (NET_BUF_SIZE - (data_end_ - buf_)); }    
-  size_t get_data_len() { return (data_end_ - data_start_); }    
-  void data_added(size_t count)
-  { 
-    data_end_ += count; 
-    data_end_ = data_end_ > (buf_ + NET_BUF_SIZE)? 
-      (buf_ + NET_BUF_SIZE):
-      data_end_; 
-  }
-  void data_removed(size_t count) 
-  { 
-    data_start_ += count; 
-    if (data_start_ >= data_end_) reset(); 
-  }
-  void reset() { data_start_ = buf_; data_end_ = buf_; }               
-  bool has_data() { return (data_start_ < data_end_); }
-}; // class net_buffer
-
-//
-// Operation class
-//
-//
-template <typename Stream>
-class openssl_operation
-{
-public:
-
-  // Constructor for asynchronous operations
-  openssl_operation(ssl_primitive_func primitive,
-                    Stream& socket,
-                    net_buffer& recv_buf,
-                    SSL* session,
-                    BIO* ssl_bio,
-                    user_handler_func  handler,
-                    asio::io_service::strand& strand
-                    )
-    : primitive_(primitive)
-    , user_handler_(handler)
-    , strand_(&strand)
-    , recv_buf_(recv_buf)
-    , socket_(socket)
-    , ssl_bio_(ssl_bio)
-    , session_(session)
-  {
-    write_ = boost::bind(
-      &openssl_operation::do_async_write, 
-      this, boost::arg<1>(), boost::arg<2>()
-    );
-    read_ = boost::bind(
-      &openssl_operation::do_async_read, 
-      this
-    );
-    handler_= boost::bind(
-      &openssl_operation::async_user_handler, 
-      this, boost::arg<1>(), boost::arg<2>()
-    );
-  }
-
-  // Constructor for synchronous operations
-  openssl_operation(ssl_primitive_func primitive,
-                    Stream& socket,
-                    net_buffer& recv_buf,
-                    SSL* session,
-                    BIO* ssl_bio)
-    : primitive_(primitive)
-    , strand_(0)
-    , recv_buf_(recv_buf)
-    , socket_(socket)
-    , ssl_bio_(ssl_bio)
-    , session_(session)
-  {      
-    write_ = boost::bind(
-      &openssl_operation::do_sync_write, 
-      this, boost::arg<1>(), boost::arg<2>()
-    );
-    read_ = boost::bind(
-      &openssl_operation::do_sync_read, 
-      this
-    );
-    handler_ = boost::bind(
-      &openssl_operation::sync_user_handler, 
-      this, boost::arg<1>(), boost::arg<2>()
-      );
-  }
-
-  // Start operation
-  // In case of asynchronous it returns 0, in sync mode returns success code
-  // or throws an error...
-  int start()
-  {
-    int rc = primitive_( session_ );
-
-    bool is_operation_done = (rc > 0);  
-                // For connect/accept/shutdown, the operation
-                // is done, when return code is 1
-                // for write, it is done, when is retcode > 0
-                // for read, it is done when retcode > 0
-
-    int error_code =  !is_operation_done ?
-          ::SSL_get_error( session_, rc ) :
-          0;        
-    int sys_error_code = ERR_get_error();
-
-    if (error_code == SSL_ERROR_SSL)
-      return handler_(asio::error_code(
-            sys_error_code, asio::error::get_ssl_category()), rc);
-
-    bool is_read_needed = (error_code == SSL_ERROR_WANT_READ);
-    bool is_write_needed = (error_code == SSL_ERROR_WANT_WRITE ||
-                              ::BIO_ctrl_pending( ssl_bio_ ));
-    bool is_shut_down_received = 
-      ((::SSL_get_shutdown( session_ ) & SSL_RECEIVED_SHUTDOWN) == 
-          SSL_RECEIVED_SHUTDOWN);
-    bool is_shut_down_sent = 
-      ((::SSL_get_shutdown( session_ ) & SSL_SENT_SHUTDOWN) ==
-            SSL_SENT_SHUTDOWN);
-
-    if (is_shut_down_sent && is_shut_down_received
-        && is_operation_done && !is_write_needed)
-      // SSL connection is shut down cleanly
-      return handler_(asio::error_code(), 1);
-
-    if (is_shut_down_received && !is_operation_done)
-      // Shutdown has been requested, while we were reading or writing...
-      // abort our action...
-      return handler_(asio::error::shut_down, 0);
-
-    if (!is_operation_done && !is_read_needed && !is_write_needed 
-      && !is_shut_down_sent)
-    {
-      // The operation has failed... It is not completed and does 
-      // not want network communication nor does want to send shutdown out...
-      if (error_code == SSL_ERROR_SYSCALL)
-      {
-        return handler_(asio::error_code(
-              sys_error_code, asio::error::system_category), rc); 
-      }
-      else
-      {
-        return handler_(asio::error_code(
-              sys_error_code, asio::error::get_ssl_category()), rc); 
-      }
-    }
-
-    if (!is_operation_done && !is_write_needed)
-    {
-      // We may have left over data that we can pass to SSL immediately
-      if (recv_buf_.get_data_len() > 0)
-      {
-        // Pass the buffered data to SSL
-        int written = ::BIO_write
-        ( 
-          ssl_bio_, 
-          recv_buf_.get_data_start(), 
-          recv_buf_.get_data_len() 
-        );
-
-        if (written > 0)
-        {
-          recv_buf_.data_removed(written);
-        }
-        else if (written < 0)
-        {
-          if (!BIO_should_retry(ssl_bio_))
-          {
-            // Some serios error with BIO....
-            return handler_(asio::error::no_recovery, 0);
-          }
-        }
-
-        return start();
-      }
-      else if (is_read_needed || (is_shut_down_sent && !is_shut_down_received))
-      {
-        return read_();
-      }
-    }
-
-    // Continue with operation, flush any SSL data out to network...
-    return write_(is_operation_done, rc); 
-  }
-
-// Private implementation
-private:
-  typedef boost::function<int (const asio::error_code&, int)>
-    int_handler_func;
-  typedef boost::function<int (bool, int)> write_func;
-  typedef boost::function<int ()> read_func;
-
-  ssl_primitive_func  primitive_;
-  user_handler_func  user_handler_;
-  asio::io_service::strand* strand_;
-  write_func  write_;
-  read_func  read_;
-  int_handler_func handler_;
-    
-  net_buffer send_buf_; // buffers for network IO
-
-  // The recv buffer is owned by the stream, not the operation, since there can
-  // be left over bytes after passing the data up to the application, and these
-  // bytes need to be kept around for the next read operation issued by the
-  // application.
-  net_buffer& recv_buf_;
-
-  Stream& socket_;
-  BIO*    ssl_bio_;
-  SSL*    session_;
-
-  //
-  int sync_user_handler(const asio::error_code& error, int rc)
-  {
-    if (!error)
-      return rc;
-
-    throw asio::system_error(error);
-  }
-    
-  int async_user_handler(asio::error_code error, int rc)
-  {
-    if (rc < 0)
-    {
-      if (!error)
-        error = asio::error::no_recovery;
-      rc = 0;
-    }
-
-    user_handler_(error, rc);
-    return 0;
-  }
-
-  // Writes bytes asynchronously from SSL to NET
-  int  do_async_write(bool is_operation_done, int rc) 
-  {
-    int len = ::BIO_ctrl_pending( ssl_bio_ );
-    if ( len )
-    { 
-      // There is something to write into net, do it...
-      len = (int)send_buf_.get_unused_len() > len? 
-        len: 
-        send_buf_.get_unused_len();
-        
-      if (len == 0)
-      {
-        // In case our send buffer is full, we have just to wait until 
-        // previous send to complete...
-        return 0;
-      }
-
-      // Read outgoing data from bio
-      len = ::BIO_read( ssl_bio_, send_buf_.get_unused_start(), len); 
-         
-      if (len > 0)
-      {
-        unsigned char *data_start = send_buf_.get_unused_start();
-        send_buf_.data_added(len);
- 
-        ASIO_ASSERT(strand_);
-        asio::async_write
-        ( 
-          socket_, 
-          asio::buffer(data_start, len),
-          strand_->wrap
-          (
-            boost::bind
-            (
-              &openssl_operation::async_write_handler, 
-              this, 
-              is_operation_done,
-              rc, 
-              asio::placeholders::error, 
-              asio::placeholders::bytes_transferred
-            )
-          )
-        );
-                  
-        return 0;
-      }
-      else if (!BIO_should_retry(ssl_bio_))
-      {
-        // Seems like fatal error
-        // reading from SSL BIO has failed...
-        handler_(asio::error::no_recovery, 0);
-        return 0;
-      }
-    }
-    
-    if (is_operation_done)
-    {
-      // Finish the operation, with success
-      handler_(asio::error_code(), rc);
-      return 0;
-    }
-    
-    // OPeration is not done and writing to net has been made...
-    // start operation again
-    start();
-          
-    return 0;
-  }
-
-  void async_write_handler(bool is_operation_done, int rc, 
-    const asio::error_code& error, size_t bytes_sent)
-  {
-    if (!error)
-    {
-      // Remove data from send buffer
-      send_buf_.data_removed(bytes_sent);
-
-      if (is_operation_done)
-        handler_(asio::error_code(), rc);
-      else
-        // Since the operation was not completed, try it again...
-        start();
-    }
-    else 
-      handler_(error, rc);
-  }
-
-  int do_async_read()
-  {
-    // Wait for new data
-    ASIO_ASSERT(strand_);
-    socket_.async_read_some
-    ( 
-      asio::buffer(recv_buf_.get_unused_start(),
-        recv_buf_.get_unused_len()),
-      strand_->wrap
-      (
-        boost::bind
-        (
-          &openssl_operation::async_read_handler, 
-          this, 
-          asio::placeholders::error, 
-          asio::placeholders::bytes_transferred
-        )
-      )
-    );
-    return 0;
-  }
-
-  void async_read_handler(const asio::error_code& error,
-      size_t bytes_recvd)
-  {
-    if (!error)
-    {
-      recv_buf_.data_added(bytes_recvd);
-
-      // Pass the received data to SSL
-      int written = ::BIO_write
-      ( 
-        ssl_bio_, 
-        recv_buf_.get_data_start(), 
-        recv_buf_.get_data_len() 
-      );
-
-      if (written > 0)
-      {
-        recv_buf_.data_removed(written);
-      }
-      else if (written < 0)
-      {
-        if (!BIO_should_retry(ssl_bio_))
-        {
-          // Some serios error with BIO....
-          handler_(asio::error::no_recovery, 0);
-          return;
-        }
-      }
-
-      // and try the SSL primitive again
-      start();
-    }
-    else
-    {
-      // Error in network level...
-      // SSL can't continue either...
-      handler_(error, 0);
-    }
-  }
-
-  // Syncronous functions...
-  int do_sync_write(bool is_operation_done, int rc)
-  {
-    int len = ::BIO_ctrl_pending( ssl_bio_ );
-    if ( len )
-    { 
-      // There is something to write into net, do it...
-      len = (int)send_buf_.get_unused_len() > len? 
-        len: 
-        send_buf_.get_unused_len();
-        
-      // Read outgoing data from bio
-      len = ::BIO_read( ssl_bio_, send_buf_.get_unused_start(), len); 
-         
-      if (len > 0)
-      {
-        size_t sent_len = asio::write( 
-                  socket_, 
-                  asio::buffer(send_buf_.get_unused_start(), len)
-                  );
-
-        send_buf_.data_added(len);
-        send_buf_.data_removed(sent_len);
-      }          
-      else if (!BIO_should_retry(ssl_bio_))
-      {
-        // Seems like fatal error
-        // reading from SSL BIO has failed...
-        throw asio::system_error(asio::error::no_recovery);
-      }
-    }
-    
-    if (is_operation_done)
-      // Finish the operation, with success
-      return rc;
-                
-    // Operation is not finished, start again.
-    return start();
-  }
-
-  int do_sync_read()
-  {
-    size_t len = socket_.read_some
-      ( 
-        asio::buffer(recv_buf_.get_unused_start(),
-          recv_buf_.get_unused_len())
-      );
-
-    // Write data to ssl
-    recv_buf_.data_added(len);
-
-    // Pass the received data to SSL
-    int written = ::BIO_write
-    ( 
-      ssl_bio_, 
-      recv_buf_.get_data_start(), 
-      recv_buf_.get_data_len() 
-    );
-
-    if (written > 0)
-    {
-      recv_buf_.data_removed(written);
-    }
-    else if (written < 0)
-    {
-      if (!BIO_should_retry(ssl_bio_))
-      {
-        // Some serios error with BIO....
-        throw asio::system_error(asio::error::no_recovery);
-      }
-    }
-
-    // Try the operation again
-    return start();
-  }
-}; // class openssl_operation
-
-} // namespace detail
-} // namespace old
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_OLD_DETAIL_OPENSSL_OPERATION_HPP
diff --git a/extern/include/asio/ssl/old/detail/openssl_stream_service.hpp b/extern/include/asio/ssl/old/detail/openssl_stream_service.hpp
deleted file mode 100644
index 9b5c9cf3..00000000
--- a/extern/include/asio/ssl/old/detail/openssl_stream_service.hpp
+++ /dev/null
@@ -1,571 +0,0 @@
-//
-// ssl/old/detail/stream_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_OLD_DETAIL_OPENSSL_STREAM_SERVICE_HPP
-#define ASIO_SSL_OLD_DETAIL_OPENSSL_STREAM_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <climits>
-#include <memory>
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/ssl/basic_context.hpp"
-#include "asio/ssl/stream_base.hpp"
-#include "asio/ssl/old/detail/openssl_operation.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-#include "asio/strand.hpp"
-#include "asio/system_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace old {
-namespace detail {
-
-class openssl_stream_service
-  : public asio::detail::service_base<openssl_stream_service>
-{
-private:
-  enum { max_buffer_size = INT_MAX };
-
-  //Base handler for asyncrhonous operations
-  template <typename Stream>
-  class base_handler
-  {
-  public:
-    typedef boost::function<
-      void (const asio::error_code&, size_t)> func_t;
-
-    base_handler(asio::io_service& io_service)
-      : op_(NULL)
-      , io_service_(io_service)
-      , work_(io_service)
-    {}
-    
-    void do_func(const asio::error_code& error, size_t size)
-    {
-      func_(error, size);
-    }
-        
-    void set_operation(openssl_operation<Stream>* op) { op_ = op; }
-    void set_func(func_t func) { func_ = func; }
-
-    ~base_handler()
-    {
-      delete op_;
-    }
-
-  private:
-    func_t func_;
-    openssl_operation<Stream>* op_;
-    asio::io_service& io_service_;
-    asio::io_service::work work_;
-  };  // class base_handler
-
-  // Handler for asynchronous IO (write/read) operations
-  template<typename Stream, typename Handler>
-  class io_handler 
-    : public base_handler<Stream>
-  {
-  public:
-    io_handler(Handler handler, asio::io_service& io_service)
-      : base_handler<Stream>(io_service)
-      , handler_(handler)
-    {
-      this->set_func(boost::bind(
-        &io_handler<Stream, Handler>::handler_impl, 
-        this, boost::arg<1>(), boost::arg<2>() ));
-    }
-
-  private:
-    Handler handler_;
-    void handler_impl(const asio::error_code& error, size_t size)
-    {
-      std::auto_ptr<io_handler<Stream, Handler> > this_ptr(this);
-      handler_(error, size);
-    }
-  };  // class io_handler 
-
-  // Handler for asyncrhonous handshake (connect, accept) functions
-  template <typename Stream, typename Handler>
-  class handshake_handler
-    : public base_handler<Stream>
-  {
-  public:
-    handshake_handler(Handler handler, asio::io_service& io_service)
-      : base_handler<Stream>(io_service)
-      , handler_(handler)
-    {
-      this->set_func(boost::bind(
-        &handshake_handler<Stream, Handler>::handler_impl, 
-        this, boost::arg<1>(), boost::arg<2>() ));
-    }
-
-  private:
-    Handler handler_;
-    void handler_impl(const asio::error_code& error, size_t)
-    {
-      std::auto_ptr<handshake_handler<Stream, Handler> > this_ptr(this);
-      handler_(error);
-    }
-
-  };  // class handshake_handler
-
-  // Handler for asyncrhonous shutdown
-  template <typename Stream, typename Handler>
-  class shutdown_handler
-    : public base_handler<Stream>
-  {
-  public:
-    shutdown_handler(Handler handler, asio::io_service& io_service)
-      : base_handler<Stream>(io_service),
-        handler_(handler)
-    { 
-      this->set_func(boost::bind(
-        &shutdown_handler<Stream, Handler>::handler_impl, 
-        this, boost::arg<1>(), boost::arg<2>() ));
-    }
-
-  private:
-    Handler handler_;
-    void handler_impl(const asio::error_code& error, size_t)
-    {
-      std::auto_ptr<shutdown_handler<Stream, Handler> > this_ptr(this);
-      handler_(error);
-    }
-  };  // class shutdown_handler
-
-public:
-  // The implementation type.
-  typedef struct impl_struct
-  {
-    ::SSL* ssl;
-    ::BIO* ext_bio;
-    net_buffer recv_buf;
-  } * impl_type;
-
-  // Construct a new stream socket service for the specified io_service.
-  explicit openssl_stream_service(asio::io_service& io_service)
-    : asio::detail::service_base<openssl_stream_service>(io_service),
-      strand_(io_service)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-  }
-
-  // Return a null stream implementation.
-  impl_type null() const
-  {
-    return 0;
-  }
-
-  // Create a new stream implementation.
-  template <typename Stream, typename Context_Service>
-  void create(impl_type& impl, Stream& /*next_layer*/,
-      basic_context<Context_Service>& context)
-  {
-    impl = new impl_struct;
-    impl->ssl = ::SSL_new(context.impl());
-    ::SSL_set_mode(impl->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
-    ::SSL_set_mode(impl->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
-    ::BIO* int_bio = 0;
-    impl->ext_bio = 0;
-    ::BIO_new_bio_pair(&int_bio, 8192, &impl->ext_bio, 8192);
-    ::SSL_set_bio(impl->ssl, int_bio, int_bio);
-  }
-
-  // Destroy a stream implementation.
-  template <typename Stream>
-  void destroy(impl_type& impl, Stream& /*next_layer*/)
-  {
-    if (impl != 0)
-    {
-      ::BIO_free(impl->ext_bio);
-      ::SSL_free(impl->ssl);
-      delete impl;
-      impl = 0;
-    }
-  }
-
-  // Perform SSL handshaking.
-  template <typename Stream>
-  asio::error_code handshake(impl_type& impl, Stream& next_layer,
-      stream_base::handshake_type type, asio::error_code& ec)
-  {
-    try
-    {
-      openssl_operation<Stream> op(
-        type == stream_base::client ?
-          &ssl_wrap<mutex_type>::SSL_connect:
-          &ssl_wrap<mutex_type>::SSL_accept,
-        next_layer,
-        impl->recv_buf,
-        impl->ssl,
-        impl->ext_bio);
-      op.start();
-    }
-    catch (asio::system_error& e)
-    {
-      ec = e.code();
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Start an asynchronous SSL handshake.
-  template <typename Stream, typename Handler>
-  void async_handshake(impl_type& impl, Stream& next_layer,
-      stream_base::handshake_type type, Handler handler)
-  {
-    typedef handshake_handler<Stream, Handler> connect_handler;
-
-    connect_handler* local_handler = 
-      new connect_handler(handler, get_io_service());
-
-    openssl_operation<Stream>* op = new openssl_operation<Stream>
-    (
-      type == stream_base::client ?
-        &ssl_wrap<mutex_type>::SSL_connect:
-        &ssl_wrap<mutex_type>::SSL_accept,
-      next_layer,
-      impl->recv_buf,
-      impl->ssl,
-      impl->ext_bio,
-      boost::bind
-      (
-        &base_handler<Stream>::do_func, 
-        local_handler,
-        boost::arg<1>(),
-        boost::arg<2>()
-      ),
-      strand_
-    );
-    local_handler->set_operation(op);
-
-    strand_.post(boost::bind(&openssl_operation<Stream>::start, op));
-  }
-
-  // Shut down SSL on the stream.
-  template <typename Stream>
-  asio::error_code shutdown(impl_type& impl, Stream& next_layer,
-      asio::error_code& ec)
-  {
-    try
-    {
-      openssl_operation<Stream> op(
-        &ssl_wrap<mutex_type>::SSL_shutdown,
-        next_layer,
-        impl->recv_buf,
-        impl->ssl,
-        impl->ext_bio);
-      op.start();
-    }
-    catch (asio::system_error& e)
-    {
-      ec = e.code();
-      return ec;
-    }
-
-    ec = asio::error_code();
-    return ec;
-  }
-
-  // Asynchronously shut down SSL on the stream.
-  template <typename Stream, typename Handler>
-  void async_shutdown(impl_type& impl, Stream& next_layer, Handler handler)
-  {
-    typedef shutdown_handler<Stream, Handler> disconnect_handler;
-
-    disconnect_handler* local_handler = 
-      new disconnect_handler(handler, get_io_service());
-
-    openssl_operation<Stream>* op = new openssl_operation<Stream>
-    (
-      &ssl_wrap<mutex_type>::SSL_shutdown,
-      next_layer,
-      impl->recv_buf,
-      impl->ssl,
-      impl->ext_bio,
-      boost::bind
-      (
-        &base_handler<Stream>::do_func, 
-        local_handler, 
-        boost::arg<1>(),
-        boost::arg<2>()
-      ),
-      strand_
-    );
-    local_handler->set_operation(op);
-
-    strand_.post(boost::bind(&openssl_operation<Stream>::start, op));        
-  }
-
-  // Write some data to the stream.
-  template <typename Stream, typename Const_Buffers>
-  std::size_t write_some(impl_type& impl, Stream& next_layer,
-      const Const_Buffers& buffers, asio::error_code& ec)
-  {
-    size_t bytes_transferred = 0;
-    try
-    {
-      asio::const_buffer buffer =
-        asio::detail::buffer_sequence_adapter<
-          asio::const_buffer, Const_Buffers>::first(buffers);
-
-      std::size_t buffer_size = asio::buffer_size(buffer);
-      if (buffer_size > max_buffer_size)
-        buffer_size = max_buffer_size;
-      else if (buffer_size == 0)
-      {
-        ec = asio::error_code();
-        return 0;
-      }
-
-      boost::function<int (SSL*)> send_func =
-        boost::bind(boost::type<int>(), &::SSL_write, boost::arg<1>(),  
-            asio::buffer_cast<const void*>(buffer),
-            static_cast<int>(buffer_size));
-      openssl_operation<Stream> op(
-        send_func,
-        next_layer,
-        impl->recv_buf,
-        impl->ssl,
-        impl->ext_bio
-      );
-      bytes_transferred = static_cast<size_t>(op.start());
-    }
-    catch (asio::system_error& e)
-    {
-      ec = e.code();
-      return 0;
-    }
-
-    ec = asio::error_code();
-    return bytes_transferred;
-  }
-
-  // Start an asynchronous write.
-  template <typename Stream, typename Const_Buffers, typename Handler>
-  void async_write_some(impl_type& impl, Stream& next_layer,
-      const Const_Buffers& buffers, Handler handler)
-  {
-    typedef io_handler<Stream, Handler> send_handler;
-
-    asio::const_buffer buffer =
-      asio::detail::buffer_sequence_adapter<
-        asio::const_buffer, Const_Buffers>::first(buffers);
-
-    std::size_t buffer_size = asio::buffer_size(buffer);
-    if (buffer_size > max_buffer_size)
-      buffer_size = max_buffer_size;
-    else if (buffer_size == 0)
-    {
-      get_io_service().post(asio::detail::bind_handler(
-            handler, asio::error_code(), 0));
-      return;
-    }
-
-    send_handler* local_handler = new send_handler(handler, get_io_service());
-
-    boost::function<int (SSL*)> send_func =
-      boost::bind(boost::type<int>(), &::SSL_write, boost::arg<1>(),
-          asio::buffer_cast<const void*>(buffer),
-          static_cast<int>(buffer_size));
-
-    openssl_operation<Stream>* op = new openssl_operation<Stream>
-    (
-      send_func,
-      next_layer,
-      impl->recv_buf,
-      impl->ssl,
-      impl->ext_bio,
-      boost::bind
-      (
-        &base_handler<Stream>::do_func, 
-        local_handler, 
-        boost::arg<1>(),
-        boost::arg<2>()
-      ),
-      strand_
-    );
-    local_handler->set_operation(op);
-
-    strand_.post(boost::bind(&openssl_operation<Stream>::start, op));        
-  }
-
-  // Read some data from the stream.
-  template <typename Stream, typename Mutable_Buffers>
-  std::size_t read_some(impl_type& impl, Stream& next_layer,
-      const Mutable_Buffers& buffers, asio::error_code& ec)
-  {
-    size_t bytes_transferred = 0;
-    try
-    {
-      asio::mutable_buffer buffer =
-        asio::detail::buffer_sequence_adapter<
-          asio::mutable_buffer, Mutable_Buffers>::first(buffers);
-
-      std::size_t buffer_size = asio::buffer_size(buffer);
-      if (buffer_size > max_buffer_size)
-        buffer_size = max_buffer_size;
-      else if (buffer_size == 0)
-      {
-        ec = asio::error_code();
-        return 0;
-      }
-
-      boost::function<int (SSL*)> recv_func =
-        boost::bind(boost::type<int>(), &::SSL_read, boost::arg<1>(),
-            asio::buffer_cast<void*>(buffer),
-            static_cast<int>(buffer_size));
-      openssl_operation<Stream> op(recv_func,
-        next_layer,
-        impl->recv_buf,
-        impl->ssl,
-        impl->ext_bio
-      );
-
-      bytes_transferred = static_cast<size_t>(op.start());
-    }
-    catch (asio::system_error& e)
-    {
-      ec = e.code();
-      return 0;
-    }
-
-    ec = asio::error_code();
-    return bytes_transferred;
-  }
-
-  // Start an asynchronous read.
-  template <typename Stream, typename Mutable_Buffers, typename Handler>
-  void async_read_some(impl_type& impl, Stream& next_layer,
-      const Mutable_Buffers& buffers, Handler handler)
-  {
-    typedef io_handler<Stream, Handler> recv_handler;
-
-    asio::mutable_buffer buffer =
-      asio::detail::buffer_sequence_adapter<
-        asio::mutable_buffer, Mutable_Buffers>::first(buffers);
-
-    std::size_t buffer_size = asio::buffer_size(buffer);
-    if (buffer_size > max_buffer_size)
-      buffer_size = max_buffer_size;
-    else if (buffer_size == 0)
-    {
-      get_io_service().post(asio::detail::bind_handler(
-            handler, asio::error_code(), 0));
-      return;
-    }
-
-    recv_handler* local_handler = new recv_handler(handler, get_io_service());
-
-    boost::function<int (SSL*)> recv_func =
-      boost::bind(boost::type<int>(), &::SSL_read, boost::arg<1>(),
-          asio::buffer_cast<void*>(buffer),
-          static_cast<int>(buffer_size));
-
-    openssl_operation<Stream>* op = new openssl_operation<Stream>
-    (
-      recv_func,
-      next_layer,
-      impl->recv_buf,
-      impl->ssl,
-      impl->ext_bio,
-      boost::bind
-      (
-        &base_handler<Stream>::do_func, 
-        local_handler, 
-        boost::arg<1>(),
-        boost::arg<2>()
-      ),
-      strand_
-    );
-    local_handler->set_operation(op);
-
-    strand_.post(boost::bind(&openssl_operation<Stream>::start, op));        
-  }
-
-  // Peek at the incoming data on the stream.
-  template <typename Stream, typename Mutable_Buffers>
-  std::size_t peek(impl_type& /*impl*/, Stream& /*next_layer*/,
-      const Mutable_Buffers& /*buffers*/, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  // Determine the amount of data that may be read without blocking.
-  template <typename Stream>
-  std::size_t in_avail(impl_type& /*impl*/, Stream& /*next_layer*/,
-      asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-private:  
-  asio::io_service::strand strand_;
-
-  typedef asio::detail::mutex mutex_type;
-  
-  template<typename Mutex>
-  struct ssl_wrap
-  {
-    static Mutex ssl_mutex_;
-
-    static int SSL_accept(SSL *ssl)
-    {
-      typename Mutex::scoped_lock lock(ssl_mutex_);
-      return ::SSL_accept(ssl);
-    }
-  
-    static int SSL_connect(SSL *ssl)
-    {
-      typename Mutex::scoped_lock lock(ssl_mutex_);
-      return ::SSL_connect(ssl);
-    }
-  
-    static int SSL_shutdown(SSL *ssl)
-    {
-      typename Mutex::scoped_lock lock(ssl_mutex_);
-      return ::SSL_shutdown(ssl);  
-    }    
-  };  
-};
-
-template<typename Mutex>
-Mutex openssl_stream_service::ssl_wrap<Mutex>::ssl_mutex_;
-
-} // namespace detail
-} // namespace old
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_OLD_DETAIL_OPENSSL_STREAM_SERVICE_HPP
diff --git a/extern/include/asio/ssl/old/stream.hpp b/extern/include/asio/ssl/old/stream.hpp
deleted file mode 100644
index 9430053e..00000000
--- a/extern/include/asio/ssl/old/stream.hpp
+++ /dev/null
@@ -1,501 +0,0 @@
-//
-// ssl/old/stream.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_OLD_STREAM_HPP
-#define ASIO_SSL_OLD_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <boost/noncopyable.hpp>
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/ssl/basic_context.hpp"
-#include "asio/ssl/stream_base.hpp"
-#include "asio/ssl/stream_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace old {
-
-/// Provides stream-oriented functionality using SSL.
-/**
- * The stream class template provides asynchronous and blocking stream-oriented
- * functionality using SSL.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Example
- * To use the SSL stream template with an ip::tcp::socket, you would write:
- * @code
- * asio::io_service io_service;
- * asio::ssl::context context(io_service, asio::ssl::context::sslv23);
- * asio::ssl::stream<asio::ip::tcp::socket> sock(io_service, context);
- * @endcode
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncRead_Stream, SyncWriteStream.
- */
-template <typename Stream, typename Service = old::stream_service>
-class stream
-  : public stream_base,
-    private boost::noncopyable
-{
-public:
-  /// The type of the next layer.
-  typedef typename remove_reference<Stream>::type next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-  /// The type of the service that will be used to provide stream operations.
-  typedef Service service_type;
-
-  /// The native implementation type of the stream.
-  typedef typename service_type::impl_type impl_type;
-
-  /// Construct a stream.
-  /**
-   * This constructor creates a stream and initialises the underlying stream
-   * object.
-   *
-   * @param arg The argument to be passed to initialise the underlying stream.
-   *
-   * @param context The SSL context to be used for the stream.
-   */
-  template <typename Arg, typename Context_Service>
-  explicit stream(Arg& arg, basic_context<Context_Service>& context)
-    : next_layer_(arg),
-      service_(asio::use_service<Service>(next_layer_.get_io_service())),
-      impl_(service_.null())
-  {
-    service_.create(impl_, next_layer_, context);
-  }
-
-  /// Destructor.
-  ~stream()
-  {
-    service_.destroy(impl_, next_layer_);
-  }
-
-  /// Get the io_service associated with the object.
-  /**
-   * This function may be used to obtain the io_service object that the stream
-   * uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A reference to the io_service object that stream will use to
-   * dispatch handlers. Ownership is not transferred to the caller.
-   */
-  asio::io_service& get_io_service()
-  {
-    return next_layer_.get_io_service();
-  }
-
-  /// Get a reference to the next layer.
-  /**
-   * This function returns a reference to the next layer in a stack of stream
-   * layers.
-   *
-   * @return A reference to the next layer in the stack of stream layers.
-   * Ownership is not transferred to the caller.
-   */
-  next_layer_type& next_layer()
-  {
-    return next_layer_;
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * stream layers.
-   *
-   * @return A reference to the lowest layer in the stack of stream layers.
-   * Ownership is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * stream layers.
-   *
-   * @return A const reference to the lowest layer in the stack of stream
-   * layers. Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get the underlying implementation in the native type.
-  /**
-   * This function may be used to obtain the underlying implementation of the
-   * context. This is intended to allow access to stream functionality that is
-   * not otherwise provided.
-   */
-  impl_type impl()
-  {
-    return impl_;
-  }
-
-  /// Perform SSL handshaking.
-  /**
-   * This function is used to perform SSL handshaking on the stream. The
-   * function call will block until handshaking is complete or an error occurs.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void handshake(handshake_type type)
-  {
-    asio::error_code ec;
-    service_.handshake(impl_, next_layer_, type, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Perform SSL handshaking.
-  /**
-   * This function is used to perform SSL handshaking on the stream. The
-   * function call will block until handshaking is complete or an error occurs.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code handshake(handshake_type type,
-      asio::error_code& ec)
-  {
-    return service_.handshake(impl_, next_layer_, type, ec);
-  }
-
-  /// Start an asynchronous SSL handshake.
-  /**
-   * This function is used to asynchronously perform an SSL handshake on the
-   * stream. This function call always returns immediately.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @param handler The handler to be called when the handshake operation
-   * completes. Copies will be made of the handler as required. The equivalent
-   * function signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   */
-  template <typename HandshakeHandler>
-  void async_handshake(handshake_type type, HandshakeHandler handler)
-  {
-    service_.async_handshake(impl_, next_layer_, type, handler);
-  }
-
-  /// Shut down SSL on the stream.
-  /**
-   * This function is used to shut down SSL on the stream. The function call
-   * will block until SSL has been shut down or an error occurs.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void shutdown()
-  {
-    asio::error_code ec;
-    service_.shutdown(impl_, next_layer_, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Shut down SSL on the stream.
-  /**
-   * This function is used to shut down SSL on the stream. The function call
-   * will block until SSL has been shut down or an error occurs.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code shutdown(asio::error_code& ec)
-  {
-    return service_.shutdown(impl_, next_layer_, ec);
-  }
-
-  /// Asynchronously shut down SSL on the stream.
-  /**
-   * This function is used to asynchronously shut down SSL on the stream. This
-   * function call always returns immediately.
-   *
-   * @param handler The handler to be called when the handshake operation
-   * completes. Copies will be made of the handler as required. The equivalent
-   * function signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   */
-  template <typename ShutdownHandler>
-  void async_shutdown(ShutdownHandler handler)
-  {
-    service_.async_shutdown(impl_, next_layer_, handler);
-  }
-
-  /// Write some data to the stream.
-  /**
-   * This function is used to write data on the stream. The function call will
-   * block until one or more bytes of data has been written successfully, or
-   * until an error occurs.
-   *
-   * @param buffers The data to be written.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The write_some 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 write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = service_.write_some(impl_, next_layer_, buffers, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Write some data to the stream.
-  /**
-   * This function is used to write data on the stream. The function call will
-   * block until one or more bytes of data has been written successfully, or
-   * until an error occurs.
-   *
-   * @param buffers The data to be written to the stream.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some 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 write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return service_.write_some(impl_, next_layer_, buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write one or more bytes of data to
-   * the stream. The function call always returns immediately.
-   *
-   * @param buffers The data to be written to the stream. Although the buffers
-   * object may be copied as necessary, ownership of the underlying buffers is
-   * retained by the caller, which must guarantee that they remain valid until
-   * the handler is called.
-   *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The equivalent function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
-   * ); @endcode
-   *
-   * @note The async_write_some operation may not transmit all of the data to
-   * the peer. Consider using the @ref async_write function if you need to
-   * ensure that all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
-  {
-    service_.async_write_some(impl_, next_layer_, buffers, handler);
-  }
-
-  /// Read some data from the stream.
-  /**
-   * This function is used to read data from the stream. The function call will
-   * block until one or more bytes of data has been read successfully, or until
-   * an error occurs.
-   *
-   * @param buffers The buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The read_some operation may not read 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 read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = service_.read_some(impl_, next_layer_, buffers, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Read some data from the stream.
-  /**
-   * This function is used to read data from the stream. The function call will
-   * block until one or more bytes of data has been read successfully, or until
-   * an error occurs.
-   *
-   * @param buffers The buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read 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 read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return service_.read_some(impl_, next_layer_, buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read one or more bytes of data from
-   * the stream. The function call always returns immediately.
-   *
-   * @param buffers The buffers into which the data will be read. Although the
-   * buffers object may be copied as necessary, ownership of the underlying
-   * buffers is retained by the caller, which must guarantee that they remain
-   * valid until the handler is called.
-   *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The equivalent function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
-   * ); @endcode
-   *
-   * @note The async_read_some operation may not read all of the requested
-   * number of bytes. Consider using the @ref async_read function if you need to
-   * ensure that the requested amount of data is read before the asynchronous
-   * operation completes.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
-  {
-    service_.async_read_some(impl_, next_layer_, buffers, handler);
-  }
-
-  /// Peek at the incoming data on the stream.
-  /**
-   * This function is used to peek at the incoming data on the stream, without
-   * removing it from the input queue. The function call will block until data
-   * has been read successfully or an error occurs.
-   *
-   * @param buffers The buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = service_.peek(impl_, next_layer_, buffers, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Peek at the incoming data on the stream.
-  /**
-   * This function is used to peek at the incoming data on the stream, withoutxi
-   * removing it from the input queue. The function call will block until data
-   * has been read successfully or an error occurs.
-   *
-   * @param buffers The buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return service_.peek(impl_, next_layer_, buffers, ec);
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  /**
-   * This function is used to determine the amount of data, in bytes, that may
-   * be read from the stream without blocking.
-   *
-   * @returns The number of bytes of data that can be read without blocking.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  std::size_t in_avail()
-  {
-    asio::error_code ec;
-    std::size_t s = service_.in_avail(impl_, next_layer_, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  /**
-   * This function is used to determine the amount of data, in bytes, that may
-   * be read from the stream without blocking.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes of data that can be read without blocking.
-   */
-  std::size_t in_avail(asio::error_code& ec)
-  {
-    return service_.in_avail(impl_, next_layer_, ec);
-  }
-
-private:
-  /// The next layer.
-  Stream next_layer_;
-
-  /// The backend service implementation.
-  service_type& service_;
-
-  /// The underlying native implementation.
-  impl_type impl_;
-};
-
-} // namespace old
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_OLD_STREAM_HPP
diff --git a/extern/include/asio/ssl/old/stream_service.hpp b/extern/include/asio/ssl/old/stream_service.hpp
deleted file mode 100644
index fc9d7981..00000000
--- a/extern/include/asio/ssl/old/stream_service.hpp
+++ /dev/null
@@ -1,184 +0,0 @@
-//
-// ssl/old/stream_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_OLD_STREAM_SERVICE_HPP
-#define ASIO_SSL_OLD_STREAM_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <boost/noncopyable.hpp>
-#include "asio/io_service.hpp"
-#include "asio/ssl/basic_context.hpp"
-#include "asio/ssl/old/detail/openssl_stream_service.hpp"
-#include "asio/ssl/stream_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace old {
-
-/// Default service implementation for an SSL stream.
-class stream_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
-#else
-  : public asio::detail::service_base<stream_service>
-#endif
-{
-private:
-  // The type of the platform-specific implementation.
-  typedef old::detail::openssl_stream_service service_impl_type;
-
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static asio::io_service::id id;
-#endif
-
-  /// The type of a stream implementation.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined impl_type;
-#else
-  typedef service_impl_type::impl_type impl_type;
-#endif
-
-  /// Construct a new stream service for the specified io_service.
-  explicit stream_service(asio::io_service& io_service)
-    : asio::detail::service_base<stream_service>(io_service),
-      service_impl_(asio::use_service<service_impl_type>(io_service))
-  {
-  }
-
-  /// Return a null stream implementation.
-  impl_type null() const
-  {
-    return service_impl_.null();
-  }
-
-  /// Create a new stream implementation.
-  template <typename Stream, typename Context_Service>
-  void create(impl_type& impl, Stream& next_layer,
-      basic_context<Context_Service>& context)
-  {
-    service_impl_.create(impl, next_layer, context);
-  }
-
-  /// Destroy a stream implementation.
-  template <typename Stream>
-  void destroy(impl_type& impl, Stream& next_layer)
-  {
-    service_impl_.destroy(impl, next_layer);
-  }
-
-  /// Perform SSL handshaking.
-  template <typename Stream>
-  asio::error_code handshake(impl_type& impl, Stream& next_layer,
-      stream_base::handshake_type type, asio::error_code& ec)
-  {
-    return service_impl_.handshake(impl, next_layer, type, ec);
-  }
-
-  /// Start an asynchronous SSL handshake.
-  template <typename Stream, typename HandshakeHandler>
-  void async_handshake(impl_type& impl, Stream& next_layer,
-      stream_base::handshake_type type, HandshakeHandler handler)
-  {
-    service_impl_.async_handshake(impl, next_layer, type, handler);
-  }
-
-  /// Shut down SSL on the stream.
-  template <typename Stream>
-  asio::error_code shutdown(impl_type& impl, Stream& next_layer,
-      asio::error_code& ec)
-  {
-    return service_impl_.shutdown(impl, next_layer, ec);
-  }
-
-  /// Asynchronously shut down SSL on the stream.
-  template <typename Stream, typename ShutdownHandler>
-  void async_shutdown(impl_type& impl, Stream& next_layer,
-      ShutdownHandler handler)
-  {
-    service_impl_.async_shutdown(impl, next_layer, handler);
-  }
-
-  /// Write some data to the stream.
-  template <typename Stream, typename ConstBufferSequence>
-  std::size_t write_some(impl_type& impl, Stream& next_layer,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return service_impl_.write_some(impl, next_layer, buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  template <typename Stream, typename ConstBufferSequence,
-      typename WriteHandler>
-  void async_write_some(impl_type& impl, Stream& next_layer,
-      const ConstBufferSequence& buffers, WriteHandler handler)
-  {
-    service_impl_.async_write_some(impl, next_layer, buffers, handler);
-  }
-
-  /// Read some data from the stream.
-  template <typename Stream, typename MutableBufferSequence>
-  std::size_t read_some(impl_type& impl, Stream& next_layer,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return service_impl_.read_some(impl, next_layer, buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  template <typename Stream, typename MutableBufferSequence,
-      typename ReadHandler>
-  void async_read_some(impl_type& impl, Stream& next_layer,
-      const MutableBufferSequence& buffers, ReadHandler handler)
-  {
-    service_impl_.async_read_some(impl, next_layer, buffers, handler);
-  }
-
-  /// Peek at the incoming data on the stream.
-  template <typename Stream, typename MutableBufferSequence>
-  std::size_t peek(impl_type& impl, Stream& next_layer,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return service_impl_.peek(impl, next_layer, buffers, ec);
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  template <typename Stream>
-  std::size_t in_avail(impl_type& impl, Stream& next_layer,
-      asio::error_code& ec)
-  {
-    return service_impl_.in_avail(impl, next_layer, ec);
-  }
-
-private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-  }
-
-  // The service that provides the platform-specific implementation.
-  service_impl_type& service_impl_;
-};
-
-} // namespace old
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_OLD_STREAM_SERVICE_HPP
diff --git a/extern/include/asio/ssl/rfc2818_verification.hpp b/extern/include/asio/ssl/rfc2818_verification.hpp
index d1a32ebc..3589f538 100644
--- a/extern/include/asio/ssl/rfc2818_verification.hpp
+++ b/extern/include/asio/ssl/rfc2818_verification.hpp
@@ -2,7 +2,7 @@
 // ssl/rfc2818_verification.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,19 +17,15 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include <string>
-# include "asio/ssl/detail/openssl_types.hpp"
-# include "asio/ssl/verify_context.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include <string>
+#include "asio/ssl/detail/openssl_types.hpp"
+#include "asio/ssl/verify_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace ssl {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 /// Verifies a certificate against a hostname according to the rules described
 /// in RFC 2818.
 /**
@@ -46,9 +42,9 @@ namespace ssl {
  * ctx.set_default_verify_paths();
  *
  * // Open a socket and connect it to the remote host.
- * asio::io_service io_service;
- * ssl_socket sock(io_service, ctx);
- * tcp::resolver resolver(io_service);
+ * asio::io_context io_context;
+ * ssl_socket sock(io_context, ctx);
+ * tcp::resolver resolver(io_context);
  * tcp::resolver::query query("host.name", "https");
  * asio::connect(sock.lowest_layer(), resolver.resolve(query));
  * sock.lowest_layer().set_option(tcp::no_delay(true));
@@ -86,8 +82,6 @@ class rfc2818_verification
   std::string host_;
 };
 
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace ssl
 } // namespace asio
 
diff --git a/extern/include/asio/ssl/stream.hpp b/extern/include/asio/ssl/stream.hpp
index 1bbc0250..2b221ed5 100644
--- a/extern/include/asio/ssl/stream.hpp
+++ b/extern/include/asio/ssl/stream.hpp
@@ -2,7 +2,7 @@
 // ssl/stream.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,36 +17,26 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/old/stream.hpp"
-#else // defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/async_result.hpp"
-# include "asio/detail/buffer_sequence_adapter.hpp"
-# include "asio/detail/handler_type_requirements.hpp"
-# include "asio/detail/noncopyable.hpp"
-# include "asio/detail/type_traits.hpp"
-# include "asio/ssl/context.hpp"
-# include "asio/ssl/detail/buffered_handshake_op.hpp"
-# include "asio/ssl/detail/handshake_op.hpp"
-# include "asio/ssl/detail/io.hpp"
-# include "asio/ssl/detail/read_op.hpp"
-# include "asio/ssl/detail/shutdown_op.hpp"
-# include "asio/ssl/detail/stream_core.hpp"
-# include "asio/ssl/detail/write_op.hpp"
-# include "asio/ssl/stream_base.hpp"
-#endif // defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/async_result.hpp"
+#include "asio/detail/buffer_sequence_adapter.hpp"
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/noncopyable.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/ssl/context.hpp"
+#include "asio/ssl/detail/buffered_handshake_op.hpp"
+#include "asio/ssl/detail/handshake_op.hpp"
+#include "asio/ssl/detail/io.hpp"
+#include "asio/ssl/detail/read_op.hpp"
+#include "asio/ssl/detail/shutdown_op.hpp"
+#include "asio/ssl/detail/stream_core.hpp"
+#include "asio/ssl/detail/write_op.hpp"
+#include "asio/ssl/stream_base.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace ssl {
 
-#if defined(ASIO_ENABLE_OLD_SSL)
-
-using asio::ssl::old::stream;
-
-#else // defined(ASIO_ENABLE_OLD_SSL)
-
 /// Provides stream-oriented functionality using SSL.
 /**
  * The stream class template provides asynchronous and blocking stream-oriented
@@ -61,9 +51,9 @@ using asio::ssl::old::stream;
  * @par Example
  * To use the SSL stream template with an ip::tcp::socket, you would write:
  * @code
- * asio::io_service io_service;
+ * asio::io_context io_context;
  * asio::ssl::context ctx(asio::ssl::context::sslv23);
- * asio::ssl::stream<asio:ip::tcp::socket> sock(io_service, ctx);
+ * asio::ssl::stream<asio:ip::tcp::socket> sock(io_context, ctx);
  * @endcode
  *
  * @par Concepts:
@@ -84,15 +74,16 @@ class stream :
     SSL* ssl;
   };
 
-  /// (Deprecated: Use native_handle_type.) The underlying implementation type.
-  typedef impl_struct* impl_type;
-
   /// The type of the next layer.
   typedef typename remove_reference<Stream>::type next_layer_type;
 
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
+  /// The type of the executor associated with the object.
+  typedef typename lowest_layer_type::executor_type executor_type;
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Construct a stream.
   /**
    * This constructor creates a stream and initialises the underlying stream
@@ -103,30 +94,58 @@ class stream :
    * @param ctx The SSL context to be used for the stream.
    */
   template <typename Arg>
+  stream(Arg&& arg, context& ctx)
+    : next_layer_(ASIO_MOVE_CAST(Arg)(arg)),
+      core_(ctx.native_handle(),
+          next_layer_.lowest_layer().get_executor().context())
+  {
+  }
+#else // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  template <typename Arg>
   stream(Arg& arg, context& ctx)
     : next_layer_(arg),
-      core_(ctx.native_handle(), next_layer_.lowest_layer().get_io_service())
+      core_(ctx.native_handle(),
+          next_layer_.lowest_layer().get_executor().context())
   {
-    backwards_compatible_impl_.ssl = core_.engine_.native_handle();
   }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destructor.
+  /**
+   * @note A @c stream object must not be destroyed while there are pending
+   * asynchronous operations associated with it.
+   */
   ~stream()
   {
   }
 
-  /// Get the io_service associated with the object.
+  /// Get the executor associated with the object.
   /**
-   * This function may be used to obtain the io_service object that the stream
+   * This function may be used to obtain the executor object that the stream
    * uses to dispatch handlers for asynchronous operations.
    *
-   * @return A reference to the io_service object that stream will use to
-   * dispatch handlers. Ownership is not transferred to the caller.
+   * @return A copy of the executor that stream will use to dispatch handlers.
    */
-  asio::io_service& get_io_service()
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return next_layer_.lowest_layer().get_executor();
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_context()
+  {
+    return next_layer_.lowest_layer().get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  asio::io_context& get_io_service()
   {
     return next_layer_.lowest_layer().get_io_service();
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   /// Get the underlying implementation in the native type.
   /**
@@ -139,7 +158,7 @@ class stream :
    * suitable for passing to functions such as @c SSL_get_verify_result and
    * @c SSL_get_peer_certificate:
    * @code
-   * asio::ssl::stream<asio:ip::tcp::socket> sock(io_service, ctx);
+   * asio::ssl::stream<asio:ip::tcp::socket> sock(io_context, ctx);
    *
    * // ... establish connection and perform handshake ...
    *
@@ -157,18 +176,6 @@ class stream :
     return core_.engine_.native_handle();
   }
 
-  /// (Deprecated: Use native_handle().) Get the underlying implementation in
-  /// the native type.
-  /**
-   * This function may be used to obtain the underlying implementation of the
-   * context. This is intended to allow access to stream functionality that is
-   * not otherwise provided.
-   */
-  impl_type impl()
-  {
-    return &backwards_compatible_impl_;
-  }
-
   /// Get a reference to the next layer.
   /**
    * This function returns a reference to the next layer in a stack of stream
@@ -252,10 +259,11 @@ class stream :
    *
    * @note Calls @c SSL_set_verify.
    */
-  asio::error_code set_verify_mode(
+  ASIO_SYNC_OP_VOID set_verify_mode(
       verify_mode v, asio::error_code& ec)
   {
-    return core_.engine_.set_verify_mode(v, ec);
+    core_.engine_.set_verify_mode(v, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Set the peer verification depth.
@@ -289,10 +297,11 @@ class stream :
    *
    * @note Calls @c SSL_set_verify_depth.
    */
-  asio::error_code set_verify_depth(
+  ASIO_SYNC_OP_VOID set_verify_depth(
       int depth, asio::error_code& ec)
   {
-    return core_.engine_.set_verify_depth(depth, ec);
+    core_.engine_.set_verify_depth(depth, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Set the callback used to verify peer certificates.
@@ -340,11 +349,12 @@ class stream :
    * @note Calls @c SSL_set_verify.
    */
   template <typename VerifyCallback>
-  asio::error_code set_verify_callback(VerifyCallback callback,
+  ASIO_SYNC_OP_VOID set_verify_callback(VerifyCallback callback,
       asio::error_code& ec)
   {
-    return core_.engine_.set_verify_callback(
+    core_.engine_.set_verify_callback(
         new detail::verify_callback<VerifyCallback>(callback), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform SSL handshaking.
@@ -374,11 +384,11 @@ class stream :
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code handshake(handshake_type type,
+  ASIO_SYNC_OP_VOID handshake(handshake_type type,
       asio::error_code& ec)
   {
     detail::io(next_layer_, core_, detail::handshake_op(type), ec);
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform SSL handshaking.
@@ -414,12 +424,12 @@ class stream :
    * @param ec Set to indicate what error occurred, if any.
    */
   template <typename ConstBufferSequence>
-  asio::error_code handshake(handshake_type type,
+  ASIO_SYNC_OP_VOID handshake(handshake_type type,
       const ConstBufferSequence& buffers, asio::error_code& ec)
   {
     detail::io(next_layer_, core_,
         detail::buffered_handshake_op<ConstBufferSequence>(type, buffers), ec);
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous SSL handshake.
@@ -447,12 +457,11 @@ class stream :
     // not meet the documented type requirements for a HandshakeHandler.
     ASIO_HANDSHAKE_HANDLER_CHECK(HandshakeHandler, handler) type_check;
 
-    asio::detail::async_result_init<
-      HandshakeHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(HandshakeHandler)(handler));
+    asio::async_completion<HandshakeHandler,
+      void (asio::error_code)> init(handler);
 
     detail::async_io(next_layer_, core_,
-        detail::handshake_op(type), init.handler);
+        detail::handshake_op(type), init.completion_handler);
 
     return init.result.get();
   }
@@ -489,13 +498,12 @@ class stream :
     ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK(
         BufferedHandshakeHandler, handler) type_check;
 
-    asio::detail::async_result_init<BufferedHandshakeHandler,
-      void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(BufferedHandshakeHandler)(handler));
+    asio::async_completion<BufferedHandshakeHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     detail::async_io(next_layer_, core_,
         detail::buffered_handshake_op<ConstBufferSequence>(type, buffers),
-        init.handler);
+        init.completion_handler);
 
     return init.result.get();
   }
@@ -521,10 +529,10 @@ class stream :
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code shutdown(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID shutdown(asio::error_code& ec)
   {
     detail::io(next_layer_, core_, detail::shutdown_op(), ec);
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Asynchronously shut down SSL on the stream.
@@ -548,11 +556,11 @@ class stream :
     // not meet the documented type requirements for a ShutdownHandler.
     ASIO_SHUTDOWN_HANDLER_CHECK(ShutdownHandler, handler) type_check;
 
-    asio::detail::async_result_init<
-      ShutdownHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(ShutdownHandler)(handler));
+    asio::async_completion<ShutdownHandler,
+      void (asio::error_code)> init(handler);
 
-    detail::async_io(next_layer_, core_, detail::shutdown_op(), init.handler);
+    detail::async_io(next_layer_, core_, detail::shutdown_op(),
+        init.completion_handler);
 
     return init.result.get();
   }
@@ -638,12 +646,12 @@ class stream :
     // not meet the documented type requirements for a WriteHandler.
     ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-    asio::detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    asio::async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     detail::async_io(next_layer_, core_,
-        detail::write_op<ConstBufferSequence>(buffers), init.handler);
+        detail::write_op<ConstBufferSequence>(buffers),
+        init.completion_handler);
 
     return init.result.get();
   }
@@ -730,12 +738,12 @@ class stream :
     // not meet the documented type requirements for a ReadHandler.
     ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-    asio::detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    asio::async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
     detail::async_io(next_layer_, core_,
-        detail::read_op<MutableBufferSequence>(buffers), init.handler);
+        detail::read_op<MutableBufferSequence>(buffers),
+        init.completion_handler);
 
     return init.result.get();
   }
@@ -743,11 +751,8 @@ class stream :
 private:
   Stream next_layer_;
   detail::stream_core core_;
-  impl_struct backwards_compatible_impl_;
 };
 
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace ssl
 } // namespace asio
 
diff --git a/extern/include/asio/ssl/stream_base.hpp b/extern/include/asio/ssl/stream_base.hpp
index ed74134d..56873e4a 100644
--- a/extern/include/asio/ssl/stream_base.hpp
+++ b/extern/include/asio/ssl/stream_base.hpp
@@ -2,7 +2,7 @@
 // ssl/stream_base.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ssl/stream_service.hpp b/extern/include/asio/ssl/stream_service.hpp
deleted file mode 100644
index fe9ff46b..00000000
--- a/extern/include/asio/ssl/stream_service.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// ssl/stream_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_STREAM_SERVICE_HPP
-#define ASIO_SSL_STREAM_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/ssl/old/stream_service.hpp"
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-#if defined(ASIO_ENABLE_OLD_SSL)
-
-using asio::ssl::old::stream_service;
-
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_STREAM_SERVICE_HPP
diff --git a/extern/include/asio/ssl/verify_context.hpp b/extern/include/asio/ssl/verify_context.hpp
index c527aa9e..e1726971 100644
--- a/extern/include/asio/ssl/verify_context.hpp
+++ b/extern/include/asio/ssl/verify_context.hpp
@@ -2,7 +2,7 @@
 // ssl/verify_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,18 +17,14 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-# include "asio/detail/noncopyable.hpp"
-# include "asio/ssl/detail/openssl_types.hpp"
-#endif // !defined(ASIO_ENABLE_OLD_SSL)
+#include "asio/detail/noncopyable.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace ssl {
 
-#if !defined(ASIO_ENABLE_OLD_SSL)
-
 /// A simple wrapper around the X509_STORE_CTX type, used during verification of
 /// a peer certificate.
 /**
@@ -63,8 +59,6 @@ class verify_context
   native_handle_type handle_;
 };
 
-#endif // defined(ASIO_ENABLE_OLD_SSL)
-
 } // namespace ssl
 } // namespace asio
 
diff --git a/extern/include/asio/ssl/verify_mode.hpp b/extern/include/asio/ssl/verify_mode.hpp
index adea0f0c..8c4b3942 100644
--- a/extern/include/asio/ssl/verify_mode.hpp
+++ b/extern/include/asio/ssl/verify_mode.hpp
@@ -2,7 +2,7 @@
 // ssl/verify_mode.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/steady_timer.hpp b/extern/include/asio/steady_timer.hpp
index 8e7ca68d..3ede2084 100644
--- a/extern/include/asio/steady_timer.hpp
+++ b/extern/include/asio/steady_timer.hpp
@@ -2,7 +2,7 @@
 // steady_timer.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,21 +17,13 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_HAS_STD_CHRONO) \
-  || defined(ASIO_HAS_BOOST_CHRONO) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#if defined(ASIO_HAS_STD_CHRONO)
-# include <chrono>
-#elif defined(ASIO_HAS_BOOST_CHRONO)
-# include <boost/chrono/system_clocks.hpp>
-#endif
+#if defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
 
 #include "asio/basic_waitable_timer.hpp"
+#include "asio/detail/chrono.hpp"
 
 namespace asio {
 
-#if defined(GENERATING_DOCUMENTATION)
 /// Typedef for a timer based on the steady clock.
 /**
  * This typedef uses the C++11 @c &lt;chrono&gt; standard library facility, if
@@ -42,20 +34,9 @@ namespace asio {
  * @endcode
  */
 typedef basic_waitable_timer<chrono::steady_clock> steady_timer;
-#elif defined(ASIO_HAS_STD_CHRONO)
-# if defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
-typedef basic_waitable_timer<std::chrono::monotonic_clock> steady_timer;
-# else // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
-typedef basic_waitable_timer<std::chrono::steady_clock> steady_timer;
-# endif // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
-#elif defined(ASIO_HAS_BOOST_CHRONO)
-typedef basic_waitable_timer<boost::chrono::steady_clock> steady_timer;
-#endif
 
 } // namespace asio
 
-#endif // defined(ASIO_HAS_STD_CHRONO) 
-       //   || defined(ASIO_HAS_BOOST_CHRONO)
-       //   || defined(GENERATING_DOCUMENTATION)
+#endif // defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
 
 #endif // ASIO_STEADY_TIMER_HPP
diff --git a/extern/include/asio/strand.hpp b/extern/include/asio/strand.hpp
index c98c39c4..ea78ef02 100644
--- a/extern/include/asio/strand.hpp
+++ b/extern/include/asio/strand.hpp
@@ -2,7 +2,7 @@
 // strand.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,237 +16,271 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/strand_service.hpp"
-#include "asio/detail/wrapped_handler.hpp"
-#include "asio/io_service.hpp"
+#include "asio/detail/strand_executor_service.hpp"
+#include "asio/detail/type_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 
-/// Provides serialised handler execution.
-/**
- * The io_service::strand class provides the ability to post and dispatch
- * handlers with the guarantee that none of those handlers will execute
- * concurrently.
- *
- * @par Order of handler invocation
- * Given:
- *
- * @li a strand object @c s
- *
- * @li an object @c a meeting completion handler requirements
- *
- * @li an object @c a1 which is an arbitrary copy of @c a made by the
- * implementation
- *
- * @li an object @c b meeting completion handler requirements
- *
- * @li an object @c b1 which is an arbitrary copy of @c b made by the
- * implementation
- *
- * if any of the following conditions are true:
- *
- * @li @c s.post(a) happens-before @c s.post(b)
- * 
- * @li @c s.post(a) happens-before @c s.dispatch(b), where the latter is
- * performed outside the strand
- * 
- * @li @c s.dispatch(a) happens-before @c s.post(b), where the former is
- * performed outside the strand
- * 
- * @li @c s.dispatch(a) happens-before @c s.dispatch(b), where both are
- * performed outside the strand
- *   
- * then @c asio_handler_invoke(a1, &a1) happens-before
- * @c asio_handler_invoke(b1, &b1).
- * 
- * Note that in the following case:
- * @code async_op_1(..., s.wrap(a));
- * async_op_2(..., s.wrap(b)); @endcode
- * the completion of the first async operation will perform @c s.dispatch(a),
- * and the second will perform @c s.dispatch(b), but the order in which those
- * are performed is unspecified. That is, you cannot state whether one
- * happens-before the other. Therefore none of the above conditions are met and
- * no ordering guarantee is made.
- *
- * @note The implementation makes no guarantee that handlers posted or
- * dispatched through different @c strand objects will be invoked concurrently.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Dispatcher.
- */
-class io_service::strand
+/// Provides serialised function invocation for any executor type.
+template <typename Executor>
+class strand
 {
 public:
-  /// Constructor.
+  /// The type of the underlying executor.
+  typedef Executor inner_executor_type;
+
+  /// Default constructor.
   /**
-   * Constructs the strand.
-   *
-   * @param io_service The io_service object that the strand will use to
-   * dispatch handlers that are ready to be run.
+   * This constructor is only valid if the underlying executor type is default
+   * constructible.
    */
-  explicit strand(asio::io_service& io_service)
-    : service_(asio::use_service<
-        asio::detail::strand_service>(io_service))
+  strand()
+    : executor_(),
+      impl_(use_service<detail::strand_executor_service>(
+            executor_.context()).create_implementation())
   {
-    service_.construct(impl_);
   }
 
-  /// Destructor.
+  /// Construct a strand for the specified executor.
+  explicit strand(const Executor& e)
+    : executor_(e),
+      impl_(use_service<detail::strand_executor_service>(
+            executor_.context()).create_implementation())
+  {
+  }
+
+  /// Copy constructor.
+  strand(const strand& other) ASIO_NOEXCEPT
+    : executor_(other.executor_),
+      impl_(other.impl_)
+  {
+  }
+
+  /// Converting constructor.
   /**
-   * Destroys a strand.
-   *
-   * Handlers posted through the strand that have not yet been invoked will
-   * still be dispatched in a way that meets the guarantee of non-concurrency.
+   * This constructor is only valid if the @c OtherExecutor type is convertible
+   * to @c Executor.
    */
-  ~strand()
+  template <class OtherExecutor>
+  strand(
+      const strand<OtherExecutor>& other) ASIO_NOEXCEPT
+    : executor_(other.executor_),
+      impl_(other.impl_)
+  {
+  }
+
+  /// Assignment operator.
+  strand& operator=(const strand& other) ASIO_NOEXCEPT
   {
+    executor_ = other.executor_;
+    impl_ = other.impl_;
+    return *this;
   }
 
-  /// Get the io_service associated with the strand.
+  /// Converting assignment operator.
   /**
-   * 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.
+   * This assignment operator is only valid if the @c OtherExecutor type is
+   * convertible to @c Executor.
    */
-  asio::io_service& get_io_service()
+  template <class OtherExecutor>
+  strand& operator=(
+      const strand<OtherExecutor>& other) ASIO_NOEXCEPT
+  {
+    executor_ = other.executor_;
+    impl_ = other.impl_;
+    return *this;
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  strand(strand&& other) ASIO_NOEXCEPT
+    : executor_(ASIO_MOVE_CAST(Executor)(other.executor_)),
+      impl_(ASIO_MOVE_CAST(implementation_type)(other.impl_))
   {
-    return service_.get_io_service();
   }
 
-  /// Request the strand to invoke the given handler.
+  /// Converting move constructor.
   /**
-   * This function is used to ask the strand to execute the given handler.
-   *
-   * The strand object guarantees that handlers posted or dispatched through
-   * the strand will not be executed concurrently. The handler may be executed
-   * inside this function if the guarantee can be met. If this function is
-   * called from within a handler that was posted or dispatched through the same
-   * strand, then the new handler will be executed immediately.
-   *
-   * The strand's guarantee is in addition to the guarantee provided by the
-   * underlying io_service. The io_service guarantees that the handler will only
-   * be called in a thread in which the io_service's run member function is
-   * currently being invoked.
-   *
-   * @param handler The handler to be called. The strand will make a copy of the
-   * handler object as required. The function signature of the handler must be:
-   * @code void handler(); @endcode
+   * This constructor is only valid if the @c OtherExecutor type is convertible
+   * to @c Executor.
    */
-  template <typename CompletionHandler>
-  ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
-  dispatch(ASIO_MOVE_ARG(CompletionHandler) handler)
+  template <class OtherExecutor>
+  strand(strand<OtherExecutor>&& other) ASIO_NOEXCEPT
+    : executor_(ASIO_MOVE_CAST(OtherExecutor)(other)),
+      impl_(ASIO_MOVE_CAST(implementation_type)(other.impl_))
   {
-    // If you get an error on the following line it means that your handler does
-    // not meet the documented type requirements for a CompletionHandler.
-    ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+  }
 
-    detail::async_result_init<
-      CompletionHandler, void ()> init(
-        ASIO_MOVE_CAST(CompletionHandler)(handler));
+  /// Move assignment operator.
+  strand& operator=(strand&& other) ASIO_NOEXCEPT
+  {
+    executor_ = ASIO_MOVE_CAST(Executor)(other);
+    impl_ = ASIO_MOVE_CAST(implementation_type)(other.impl_);
+    return *this;
+  }
 
-    service_.dispatch(impl_, init.handler);
+  /// Converting move assignment operator.
+  /**
+   * This assignment operator is only valid if the @c OtherExecutor type is
+   * convertible to @c Executor.
+   */
+  template <class OtherExecutor>
+  strand& operator=(
+      const strand<OtherExecutor>&& other) ASIO_NOEXCEPT
+  {
+    executor_ = ASIO_MOVE_CAST(OtherExecutor)(other);
+    impl_ = ASIO_MOVE_CAST(implementation_type)(other.impl_);
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~strand()
+  {
+  }
 
-    return init.result.get();
+  /// Obtain the underlying executor.
+  inner_executor_type get_inner_executor() const ASIO_NOEXCEPT
+  {
+    return executor_;
   }
 
-  /// Request the strand to invoke the given handler and return
-  /// immediately.
+  /// Obtain the underlying execution context.
+  execution_context& context() const ASIO_NOEXCEPT
+  {
+    return executor_.context();
+  }
+
+  /// Inform the strand that it has some outstanding work to do.
   /**
-   * This function is used to ask the strand to execute the given handler, but
-   * without allowing the strand to call the handler from inside this function.
-   *
-   * The strand object guarantees that handlers posted or dispatched through
-   * the strand will not be executed concurrently. The strand's guarantee is in
-   * addition to the guarantee provided by the underlying io_service. The
-   * io_service guarantees that the handler will only be called in a thread in
-   * which the io_service's run member function is currently being invoked.
-   *
-   * @param handler The handler to be called. The strand will make a copy of the
-   * handler object as required. The function signature of the handler must be:
-   * @code void handler(); @endcode
+   * The strand delegates this call to its underlying executor.
    */
-  template <typename CompletionHandler>
-  ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
-  post(ASIO_MOVE_ARG(CompletionHandler) handler)
+  void on_work_started() const ASIO_NOEXCEPT
   {
-    // If you get an error on the following line it means that your handler does
-    // not meet the documented type requirements for a CompletionHandler.
-    ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+    executor_.on_work_started();
+  }
 
-    detail::async_result_init<
-      CompletionHandler, void ()> init(
-        ASIO_MOVE_CAST(CompletionHandler)(handler));
+  /// Inform the strand that some work is no longer outstanding.
+  /**
+   * The strand delegates this call to its underlying executor.
+   */
+  void on_work_finished() const ASIO_NOEXCEPT
+  {
+    executor_.on_work_finished();
+  }
 
-    service_.post(impl_, init.handler);
+  /// Request the strand to invoke the given function object.
+  /**
+   * This function is used to ask the strand to execute the given function
+   * object on its underlying executor. The function object will be executed
+   * inside this function if the strand is not otherwise busy and if the
+   * underlying executor's @c dispatch() function is also able to execute the
+   * function before returning.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+  {
+    detail::strand_executor_service::dispatch(impl_,
+        executor_, ASIO_MOVE_CAST(Function)(f), a);
+  }
 
-    return init.result.get();
+  /// Request the strand to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object will never be executed inside this function.
+   * Instead, it will be scheduled by the underlying executor's defer function.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void post(ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+  {
+    detail::strand_executor_service::post(impl_,
+        executor_, ASIO_MOVE_CAST(Function)(f), a);
   }
 
-  /// Create a new handler that automatically dispatches the wrapped handler
-  /// on the strand.
+  /// Request the strand to invoke the given function object.
   /**
-   * This function is used to create a new handler function object that, when
-   * invoked, will automatically pass the wrapped handler to the strand's
-   * dispatch function.
+   * This function is used to ask the executor to execute the given function
+   * object. The function object will never be executed inside this function.
+   * Instead, it will be scheduled by the underlying executor's defer function.
    *
-   * @param handler The handler to be wrapped. The strand will make a copy of
-   * the handler object as required. The function signature of the handler must
-   * be: @code void handler(A1 a1, ... An an); @endcode
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
    *
-   * @return A function object that, when invoked, passes the wrapped handler to
-   * the strand's dispatch function. Given a function object with the signature:
-   * @code R f(A1 a1, ... An an); @endcode
-   * If this function object is passed to the wrap function like so:
-   * @code strand.wrap(f); @endcode
-   * then the return value is a function object with the signature
-   * @code void g(A1 a1, ... An an); @endcode
-   * that, when invoked, executes code equivalent to:
-   * @code strand.dispatch(boost::bind(f, a1, ... an)); @endcode
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
    */
-  template <typename Handler>
-#if defined(GENERATING_DOCUMENTATION)
-  unspecified
-#else
-  detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
-#endif
-  wrap(Handler handler)
+  template <typename Function, typename Allocator>
+  void defer(ASIO_MOVE_ARG(Function) f, const Allocator& a) const
   {
-    return detail::wrapped_handler<io_service::strand, Handler,
-        detail::is_continuation_if_running>(*this, handler);
+    detail::strand_executor_service::defer(impl_,
+        executor_, ASIO_MOVE_CAST(Function)(f), a);
   }
 
   /// Determine whether the strand is running in the current thread.
   /**
-   * @return @c true if the current thread is executing a handler that was
-   * submitted to the strand using post(), dispatch() or wrap(). Otherwise
+   * @return @c true if the current thread is executing a function that was
+   * submitted to the strand using post(), dispatch() or defer(). Otherwise
    * returns @c false.
    */
-  bool running_in_this_thread() const
+  bool running_in_this_thread() const ASIO_NOEXCEPT
+  {
+    return detail::strand_executor_service::running_in_this_thread(impl_);
+  }
+
+  /// Compare two strands for equality.
+  /**
+   * Two strands are equal if they refer to the same ordered, non-concurrent
+   * state.
+   */
+  friend bool operator==(const strand& a, const strand& b) ASIO_NOEXCEPT
+  {
+    return a.impl_ == b.impl_;
+  }
+
+  /// Compare two strands for inequality.
+  /**
+   * Two strands are equal if they refer to the same ordered, non-concurrent
+   * state.
+   */
+  friend bool operator!=(const strand& a, const strand& b) ASIO_NOEXCEPT
   {
-    return service_.running_in_this_thread(impl_);
+    return a.impl_ != b.impl_;
   }
 
 private:
-  asio::detail::strand_service& service_;
-  asio::detail::strand_service::implementation_type impl_;
+  Executor executor_;
+  typedef detail::strand_executor_service::implementation_type
+    implementation_type;
+  implementation_type impl_;
 };
 
-/// (Deprecated: Use asio::io_service::strand.) Typedef for backwards
-/// compatibility.
-typedef asio::io_service::strand strand;
-
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
+// If both io_context.hpp and strand.hpp have been included, automatically
+// include the header file needed for the io_context::strand class.
+#if !defined(ASIO_NO_EXTENSIONS)
+# if defined(ASIO_IO_CONTEXT_HPP)
+#  include "asio/io_context_strand.hpp"
+# endif // defined(ASIO_IO_CONTEXT_HPP)
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 #endif // ASIO_STRAND_HPP
diff --git a/extern/include/asio/stream_socket_service.hpp b/extern/include/asio/stream_socket_service.hpp
index 56a03209..91b0a711 100644
--- a/extern/include/asio/stream_socket_service.hpp
+++ b/extern/include/asio/stream_socket_service.hpp
@@ -2,7 +2,7 @@
 // stream_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include <cstddef>
 #include "asio/async_result.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #if defined(ASIO_WINDOWS_RUNTIME)
 # include "asio/detail/winrt_ssocket_service.hpp"
@@ -38,7 +41,7 @@ namespace asio {
 template <typename Protocol>
 class stream_socket_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<stream_socket_service<Protocol> >
 #endif
@@ -46,7 +49,7 @@ class stream_socket_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The protocol type.
@@ -73,13 +76,6 @@ class stream_socket_service
   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;
@@ -87,11 +83,11 @@ class stream_socket_service
   typedef typename service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new stream socket service for the specified io_service.
-  explicit stream_socket_service(asio::io_service& io_service)
+  /// Construct a new stream socket service for the specified io_context.
+  explicit stream_socket_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        stream_socket_service<Protocol> >(io_service),
-      service_impl_(io_service)
+        stream_socket_service<Protocol> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -117,17 +113,21 @@ class stream_socket_service
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
 
+  // All socket services have access to each other's implementations.
+  template <typename Protocol1> friend class stream_socket_service;
+
   /// Move-construct a new stream socket implementation from another protocol
   /// type.
   template <typename Protocol1>
   void converting_move_construct(implementation_type& impl,
+      stream_socket_service<Protocol1>& other_service,
       typename stream_socket_service<
         Protocol1>::implementation_type& other_impl,
       typename enable_if<is_convertible<
         Protocol1, Protocol>::value>::type* = 0)
   {
     service_impl_.template converting_move_construct<Protocol1>(
-        impl, other_impl);
+        impl, other_service.service_impl_, other_impl);
   }
 #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
@@ -138,22 +138,23 @@ class stream_socket_service
   }
 
   /// Open a stream socket.
-  asio::error_code open(implementation_type& impl,
+  ASIO_SYNC_OP_VOID open(implementation_type& impl,
       const protocol_type& protocol, asio::error_code& ec)
   {
     if (protocol.type() == ASIO_OS_DEF(SOCK_STREAM))
       service_impl_.open(impl, protocol, ec);
     else
       ec = asio::error::invalid_argument;
-    return ec;
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Assign an existing native socket to a stream socket.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const protocol_type& protocol, const native_handle_type& native_socket,
       asio::error_code& ec)
   {
-    return service_impl_.assign(impl, protocol, native_socket, ec);
+    service_impl_.assign(impl, protocol, native_socket, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is open.
@@ -163,16 +164,18 @@ class stream_socket_service
   }
 
   /// Close a stream socket implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
+  /// Release ownership of the underlying socket.
+  native_handle_type release(implementation_type& impl,
+      asio::error_code& ec)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.release(impl, ec);
   }
 
   /// Get the native socket implementation.
@@ -182,10 +185,11 @@ class stream_socket_service
   }
 
   /// Cancel all asynchronous operations associated with the socket.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
@@ -203,17 +207,19 @@ class stream_socket_service
   }
 
   /// Bind the stream socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
+  ASIO_SYNC_OP_VOID bind(implementation_type& impl,
       const endpoint_type& endpoint, asio::error_code& ec)
   {
-    return service_impl_.bind(impl, endpoint, ec);
+    service_impl_.bind(impl, endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Connect the stream socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
+  ASIO_SYNC_OP_VOID connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, asio::error_code& ec)
   {
-    return service_impl_.connect(impl, peer_endpoint, ec);
+    service_impl_.connect(impl, peer_endpoint, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Start an asynchronous connect.
@@ -224,37 +230,39 @@ class stream_socket_service
       const endpoint_type& peer_endpoint,
       ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    detail::async_result_init<
-      ConnectHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(ConnectHandler)(handler));
+    async_completion<ConnectHandler,
+      void (asio::error_code)> init(handler);
 
-    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+    service_impl_.async_connect(impl, peer_endpoint, init.completion_handler);
 
     return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
-  asio::error_code set_option(implementation_type& impl,
+  ASIO_SYNC_OP_VOID set_option(implementation_type& impl,
       const SettableSocketOption& option, asio::error_code& ec)
   {
-    return service_impl_.set_option(impl, option, ec);
+    service_impl_.set_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
-  asio::error_code get_option(const implementation_type& impl,
+  ASIO_SYNC_OP_VOID get_option(const implementation_type& impl,
       GettableSocketOption& option, asio::error_code& ec) const
   {
-    return service_impl_.get_option(impl, option, ec);
+    service_impl_.get_option(impl, option, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
-  asio::error_code io_control(implementation_type& impl,
+  ASIO_SYNC_OP_VOID io_control(implementation_type& impl,
       IoControlCommand& command, asio::error_code& ec)
   {
-    return service_impl_.io_control(impl, command, ec);
+    service_impl_.io_control(impl, command, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the socket.
@@ -264,10 +272,11 @@ class stream_socket_service
   }
 
   /// Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.non_blocking(impl, mode, ec);
+    service_impl_.non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Gets the non-blocking mode of the native socket implementation.
@@ -277,10 +286,11 @@ class stream_socket_service
   }
 
   /// Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
+  ASIO_SYNC_OP_VOID native_non_blocking(implementation_type& impl,
       bool mode, asio::error_code& ec)
   {
-    return service_impl_.native_non_blocking(impl, mode, ec);
+    service_impl_.native_non_blocking(impl, mode, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the local endpoint.
@@ -298,10 +308,36 @@ class stream_socket_service
   }
 
   /// Disable sends or receives on the socket.
-  asio::error_code shutdown(implementation_type& impl,
+  ASIO_SYNC_OP_VOID shutdown(implementation_type& impl,
       socket_base::shutdown_type what, asio::error_code& ec)
   {
-    return service_impl_.shutdown(impl, what, ec);
+    service_impl_.shutdown(impl, what, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Wait for the socket to become ready to read, ready to write, or to have
+  /// pending error conditions.
+  ASIO_SYNC_OP_VOID wait(implementation_type& impl,
+      socket_base::wait_type w, asio::error_code& ec)
+  {
+    service_impl_.wait(impl, w, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Asynchronously wait for the socket to become ready to read, ready to
+  /// write, or to have pending error conditions.
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(implementation_type& impl, socket_base::wait_type w,
+      ASIO_MOVE_ARG(WaitHandler) handler)
+  {
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    service_impl_.async_wait(impl, w, init.completion_handler);
+
+    return init.result.get();
   }
 
   /// Send the given data to the peer.
@@ -322,11 +358,10 @@ class stream_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_send(impl, buffers, flags, init.handler);
+    service_impl_.async_send(impl, buffers, flags, init.completion_handler);
 
     return init.result.get();
   }
@@ -349,20 +384,19 @@ class stream_socket_service
       socket_base::message_flags flags,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_receive(impl, buffers, flags, init.handler);
+    service_impl_.async_receive(impl, buffers, flags, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -373,4 +407,6 @@ class stream_socket_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_STREAM_SOCKET_SERVICE_HPP
diff --git a/extern/include/asio/streambuf.hpp b/extern/include/asio/streambuf.hpp
index 75cee1bf..cb3f35f7 100644
--- a/extern/include/asio/streambuf.hpp
+++ b/extern/include/asio/streambuf.hpp
@@ -2,7 +2,7 @@
 // streambuf.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/system_context.hpp b/extern/include/asio/system_context.hpp
new file mode 100644
index 00000000..ccd11134
--- /dev/null
+++ b/extern/include/asio/system_context.hpp
@@ -0,0 +1,78 @@
+//
+// system_context.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SYSTEM_CONTEXT_HPP
+#define ASIO_SYSTEM_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/scheduler.hpp"
+#include "asio/detail/thread_group.hpp"
+#include "asio/execution_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+class system_executor;
+
+/// The executor context for the system executor.
+class system_context : public execution_context
+{
+public:
+  /// The executor type associated with the context.
+  typedef system_executor executor_type;
+
+  /// Destructor shuts down all threads in the system thread pool.
+  ASIO_DECL ~system_context();
+
+  /// Obtain an executor for the context.
+  executor_type get_executor() ASIO_NOEXCEPT;
+
+  /// Signal all threads in the system thread pool to stop.
+  ASIO_DECL void stop();
+
+  /// Determine whether the system thread pool has been stopped.
+  ASIO_DECL bool stopped() const ASIO_NOEXCEPT;
+
+  /// Join all threads in the system thread pool.
+  ASIO_DECL void join();
+
+#if defined(GENERATING_DOCUMENTATION)
+private:
+#endif // defined(GENERATING_DOCUMENTATION)
+  // Constructor creates all threads in the system thread pool.
+  ASIO_DECL system_context();
+
+private:
+  friend class system_executor;
+
+  struct thread_function;
+
+  // The underlying scheduler.
+  detail::scheduler& scheduler_;
+
+  // The threads in the system thread pool.
+  detail::thread_group threads_;
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/system_context.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/system_context.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_SYSTEM_CONTEXT_HPP
diff --git a/extern/include/asio/system_error.hpp b/extern/include/asio/system_error.hpp
index 4ec121eb..63908941 100644
--- a/extern/include/asio/system_error.hpp
+++ b/extern/include/asio/system_error.hpp
@@ -2,7 +2,7 @@
 // system_error.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/system_executor.hpp b/extern/include/asio/system_executor.hpp
new file mode 100644
index 00000000..b588a21b
--- /dev/null
+++ b/extern/include/asio/system_executor.hpp
@@ -0,0 +1,129 @@
+//
+// system_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_SYSTEM_EXECUTOR_HPP
+#define ASIO_SYSTEM_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+class system_context;
+
+/// An executor that uses arbitrary threads.
+/**
+ * The system executor represents an execution context where functions are
+ * permitted to run on arbitrary threads. The post() and defer() functions
+ * schedule the function to run on an unspecified system thread pool, and
+ * dispatch() invokes the function immediately.
+ */
+class system_executor
+{
+public:
+  /// Obtain the underlying execution context.
+  system_context& context() const ASIO_NOEXCEPT;
+
+  /// Inform the executor that it has some outstanding work to do.
+  /**
+   * For the system executor, this is a no-op.
+   */
+  void on_work_started() const ASIO_NOEXCEPT
+  {
+  }
+
+  /// Inform the executor that some work is no longer outstanding.
+  /**
+   * For the system executor, this is a no-op.
+   */
+  void on_work_finished() const ASIO_NOEXCEPT
+  {
+  }
+
+  /// Request the system executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object will always be executed inside this function.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the system executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object will never be executed inside this function.
+   * Instead, it will be scheduled to run on an unspecified system thread pool.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void post(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the system executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object will never be executed inside this function.
+   * Instead, it will be scheduled to run on an unspecified system thread pool.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void defer(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Compare two executors for equality.
+  /**
+   * System executors always compare equal.
+   */
+  friend bool operator==(const system_executor&,
+      const system_executor&) ASIO_NOEXCEPT
+  {
+    return true;
+  }
+
+  /// Compare two executors for inequality.
+  /**
+   * System executors always compare equal.
+   */
+  friend bool operator!=(const system_executor&,
+      const system_executor&) ASIO_NOEXCEPT
+  {
+    return false;
+  }
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/system_executor.hpp"
+
+#endif // ASIO_SYSTEM_EXECUTOR_HPP
diff --git a/extern/include/asio/system_timer.hpp b/extern/include/asio/system_timer.hpp
index 143056ef..e75e7d4c 100644
--- a/extern/include/asio/system_timer.hpp
+++ b/extern/include/asio/system_timer.hpp
@@ -2,7 +2,7 @@
 // system_timer.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,21 +17,13 @@
 
 #include "asio/detail/config.hpp"
 
-#if defined(ASIO_HAS_STD_CHRONO) \
-  || defined(ASIO_HAS_BOOST_CHRONO) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#if defined(ASIO_HAS_STD_CHRONO)
-# include <chrono>
-#elif defined(ASIO_HAS_BOOST_CHRONO)
-# include <boost/chrono/system_clocks.hpp>
-#endif
+#if defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
 
 #include "asio/basic_waitable_timer.hpp"
+#include "asio/detail/chrono.hpp"
 
 namespace asio {
 
-#if defined(GENERATING_DOCUMENTATION)
 /// Typedef for a timer based on the system clock.
 /**
  * This typedef uses the C++11 @c &lt;chrono&gt; standard library facility, if
@@ -42,16 +34,9 @@ namespace asio {
  * @endcode
  */
 typedef basic_waitable_timer<chrono::system_clock> system_timer;
-#elif defined(ASIO_HAS_STD_CHRONO)
-typedef basic_waitable_timer<std::chrono::system_clock> system_timer;
-#elif defined(ASIO_HAS_BOOST_CHRONO)
-typedef basic_waitable_timer<boost::chrono::system_clock> system_timer;
-#endif
 
 } // namespace asio
 
-#endif // defined(ASIO_HAS_STD_CHRONO) 
-       //   || defined(ASIO_HAS_BOOST_CHRONO)
-       //   || defined(GENERATING_DOCUMENTATION)
+#endif // defined(ASIO_HAS_CHRONO) || defined(GENERATING_DOCUMENTATION)
 
 #endif // ASIO_SYSTEM_TIMER_HPP
diff --git a/extern/include/asio/thread.hpp b/extern/include/asio/thread.hpp
index 64681309..eeeef7bb 100644
--- a/extern/include/asio/thread.hpp
+++ b/extern/include/asio/thread.hpp
@@ -2,7 +2,7 @@
 // thread.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -36,12 +36,12 @@ namespace asio {
  *
  * @par Example
  * A typical use of asio::thread would be to launch a thread to run an
- * io_service's event processing loop:
+ * io_context's event processing loop:
  *
  * @par
- * @code asio::io_service io_service;
+ * @code asio::io_context io_context;
  * // ...
- * asio::thread t(boost::bind(&asio::io_service::run, &io_service));
+ * asio::thread t(boost::bind(&asio::io_context::run, &io_context));
  * // ...
  * t.join(); @endcode
  */
diff --git a/extern/include/asio/thread_pool.hpp b/extern/include/asio/thread_pool.hpp
new file mode 100644
index 00000000..f22f18d1
--- /dev/null
+++ b/extern/include/asio/thread_pool.hpp
@@ -0,0 +1,232 @@
+//
+// thread_pool.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_THREAD_POOL_HPP
+#define ASIO_THREAD_POOL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/noncopyable.hpp"
+#include "asio/detail/scheduler.hpp"
+#include "asio/detail/thread_group.hpp"
+#include "asio/execution_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// A simple fixed-size thread pool.
+/**
+ * The thread pool class is an execution context where functions are permitted
+ * to run on one of a fixed number of threads.
+ *
+ * @par Submitting tasks to the pool
+ *
+ * To submit functions to the io_context, use the @ref asio::dispatch,
+ * @ref asio::post or @ref asio::defer free functions.
+ *
+ * For example:
+ *
+ * @code void my_task()
+ * {
+ *   ...
+ * }
+ *
+ * ...
+ *
+ * // Launch the pool with four threads.
+ * asio::thread_pool pool(4);
+ *
+ * // Submit a function to the pool.
+ * asio::post(pool, my_task);
+ *
+ * // Submit a lambda object to the pool.
+ * asio::post(pool,
+ *     []()
+ *     {
+ *       ...
+ *     });
+ *
+ * // Wait for all tasks in the pool to complete.
+ * pool.join(); @endcode
+ */
+class thread_pool
+  : public execution_context
+{
+public:
+  class executor_type;
+
+  /// Constructs a pool with an automatically determined number of threads.
+  ASIO_DECL thread_pool();
+
+  /// Constructs a pool with a specified number of threads.
+  ASIO_DECL thread_pool(std::size_t num_threads);
+
+  /// Destructor.
+  /**
+   * Automatically stops and joins the pool, if not explicitly done beforehand.
+   */
+  ASIO_DECL ~thread_pool();
+
+  /// Obtains the executor associated with the pool.
+  executor_type get_executor() ASIO_NOEXCEPT;
+
+  /// Stops the threads.
+  /**
+   * This function stops the threads as soon as possible. As a result of calling
+   * @c stop(), pending function objects may be never be invoked.
+   */
+  ASIO_DECL void stop();
+
+  /// Joins the threads.
+  /**
+   * This function blocks until the threads in the pool have completed. If @c
+   * stop() is not called prior to @c join(), the @c join() call will wait
+   * until the pool has no more outstanding work.
+   */
+  ASIO_DECL void join();
+
+private:
+  friend class executor_type;
+  struct thread_function;
+
+  // The underlying scheduler.
+  detail::scheduler& scheduler_;
+
+  // The threads in the pool.
+  detail::thread_group threads_;
+};
+
+/// Executor used to submit functions to a thread pool.
+class thread_pool::executor_type
+{
+public:
+  /// Obtain the underlying execution context.
+  thread_pool& context() const ASIO_NOEXCEPT;
+
+  /// Inform the thread pool that it has some outstanding work to do.
+  /**
+   * This function is used to inform the thread pool that some work has begun.
+   * This ensures that the thread pool's join() function will not return while
+   * the work is underway.
+   */
+  void on_work_started() const ASIO_NOEXCEPT;
+
+  /// Inform the thread pool that some work is no longer outstanding.
+  /**
+   * This function is used to inform the thread pool that some work has
+   * finished. Once the count of unfinished work reaches zero, the thread
+   * pool's join() function is permitted to exit.
+   */
+  void on_work_finished() const ASIO_NOEXCEPT;
+
+  /// Request the thread pool to invoke the given function object.
+  /**
+   * This function is used to ask the thread pool to execute the given function
+   * object. If the current thread belongs to the pool, @c dispatch() executes
+   * the function before returning. Otherwise, the function will be scheduled
+   * to run on the thread pool.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the thread pool to invoke the given function object.
+  /**
+   * This function is used to ask the thread pool to execute the given function
+   * object. The function object will never be executed inside @c post().
+   * Instead, it will be scheduled to run on the thread pool.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void post(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Request the thread pool to invoke the given function object.
+  /**
+   * This function is used to ask the thread pool to execute the given function
+   * object. The function object will never be executed inside @c defer().
+   * Instead, it will be scheduled to run on the thread pool.
+   *
+   * If the current thread belongs to the thread pool, @c defer() will delay
+   * scheduling the function object until the current thread returns control to
+   * the pool.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void defer(ASIO_MOVE_ARG(Function) f, const Allocator& a) const;
+
+  /// Determine whether the thread pool is running in the current thread.
+  /**
+   * @return @c true if the current thread belongs to the pool. Otherwise
+   * returns @c false.
+   */
+  bool running_in_this_thread() const ASIO_NOEXCEPT;
+
+  /// Compare two executors for equality.
+  /**
+   * Two executors are equal if they refer to the same underlying thread pool.
+   */
+  friend bool operator==(const executor_type& a,
+      const executor_type& b) ASIO_NOEXCEPT
+  {
+    return &a.pool_ == &b.pool_;
+  }
+
+  /// Compare two executors for inequality.
+  /**
+   * Two executors are equal if they refer to the same underlying thread pool.
+   */
+  friend bool operator!=(const executor_type& a,
+      const executor_type& b) ASIO_NOEXCEPT
+  {
+    return &a.pool_ != &b.pool_;
+  }
+
+private:
+  friend class thread_pool;
+
+  // Constructor.
+  explicit executor_type(thread_pool& p) : pool_(p) {}
+
+  // The underlying thread pool.
+  thread_pool& pool_;
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/thread_pool.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/thread_pool.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_THREAD_POOL_HPP
diff --git a/extern/include/asio/time_traits.hpp b/extern/include/asio/time_traits.hpp
index 4cc4e242..72f4aabe 100644
--- a/extern/include/asio/time_traits.hpp
+++ b/extern/include/asio/time_traits.hpp
@@ -2,7 +2,7 @@
 // time_traits.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/ts/buffer.hpp b/extern/include/asio/ts/buffer.hpp
new file mode 100644
index 00000000..faf08a47
--- /dev/null
+++ b/extern/include/asio/ts/buffer.hpp
@@ -0,0 +1,24 @@
+//
+// ts/buffer.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_BUFFER_HPP
+#define ASIO_TS_BUFFER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/buffer.hpp"
+#include "asio/completion_condition.hpp"
+#include "asio/read.hpp"
+#include "asio/write.hpp"
+#include "asio/read_until.hpp"
+
+#endif // ASIO_TS_BUFFER_HPP
diff --git a/extern/include/asio/ts/executor.hpp b/extern/include/asio/ts/executor.hpp
new file mode 100644
index 00000000..8669cb6c
--- /dev/null
+++ b/extern/include/asio/ts/executor.hpp
@@ -0,0 +1,35 @@
+//
+// ts/executor.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_EXECUTOR_HPP
+#define ASIO_TS_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/handler_type.hpp"
+#include "asio/async_result.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/is_executor.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/bind_executor.hpp"
+#include "asio/executor_work_guard.hpp"
+#include "asio/system_executor.hpp"
+#include "asio/executor.hpp"
+#include "asio/dispatch.hpp"
+#include "asio/post.hpp"
+#include "asio/defer.hpp"
+#include "asio/strand.hpp"
+#include "asio/packaged_task.hpp"
+#include "asio/use_future.hpp"
+
+#endif // ASIO_TS_EXECUTOR_HPP
diff --git a/extern/include/asio/ts/internet.hpp b/extern/include/asio/ts/internet.hpp
new file mode 100644
index 00000000..6282e905
--- /dev/null
+++ b/extern/include/asio/ts/internet.hpp
@@ -0,0 +1,40 @@
+//
+// ts/internet.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_INTERNET_HPP
+#define ASIO_TS_INTERNET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/ip/address.hpp"
+#include "asio/ip/address_v4.hpp"
+#include "asio/ip/address_v4_iterator.hpp"
+#include "asio/ip/address_v4_range.hpp"
+#include "asio/ip/address_v6.hpp"
+#include "asio/ip/address_v6_iterator.hpp"
+#include "asio/ip/address_v6_range.hpp"
+#include "asio/ip/bad_address_cast.hpp"
+#include "asio/ip/basic_endpoint.hpp"
+#include "asio/ip/basic_resolver_query.hpp"
+#include "asio/ip/basic_resolver_entry.hpp"
+#include "asio/ip/basic_resolver_iterator.hpp"
+#include "asio/ip/basic_resolver.hpp"
+#include "asio/ip/host_name.hpp"
+#include "asio/ip/network_v4.hpp"
+#include "asio/ip/network_v6.hpp"
+#include "asio/ip/tcp.hpp"
+#include "asio/ip/udp.hpp"
+#include "asio/ip/v6_only.hpp"
+#include "asio/ip/unicast.hpp"
+#include "asio/ip/multicast.hpp"
+
+#endif // ASIO_TS_INTERNET_HPP
diff --git a/extern/include/asio/ts/io_context.hpp b/extern/include/asio/ts/io_context.hpp
new file mode 100644
index 00000000..b967cd63
--- /dev/null
+++ b/extern/include/asio/ts/io_context.hpp
@@ -0,0 +1,20 @@
+//
+// ts/io_context.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_IO_CONTEXT_HPP
+#define ASIO_TS_IO_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/io_context.hpp"
+
+#endif // ASIO_TS_IO_CONTEXT_HPP
diff --git a/extern/include/asio/ts/net.hpp b/extern/include/asio/ts/net.hpp
new file mode 100644
index 00000000..f96075d9
--- /dev/null
+++ b/extern/include/asio/ts/net.hpp
@@ -0,0 +1,26 @@
+//
+// ts/net.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_NET_HPP
+#define ASIO_TS_NET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/ts/netfwd.hpp"
+#include "asio/ts/executor.hpp"
+#include "asio/ts/io_context.hpp"
+#include "asio/ts/timer.hpp"
+#include "asio/ts/buffer.hpp"
+#include "asio/ts/socket.hpp"
+#include "asio/ts/internet.hpp"
+
+#endif // ASIO_TS_NET_HPP
diff --git a/extern/include/asio/ts/netfwd.hpp b/extern/include/asio/ts/netfwd.hpp
new file mode 100644
index 00000000..657a21d3
--- /dev/null
+++ b/extern/include/asio/ts/netfwd.hpp
@@ -0,0 +1,197 @@
+//
+// ts/netfwd.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_NETFWD_HPP
+#define ASIO_TS_NETFWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_CHRONO)
+# include "asio/detail/chrono.hpp"
+#endif // defined(ASIO_HAS_CHRONO)
+
+#if defined(ASIO_HAS_BOOST_DATE_TIME)
+# include "asio/detail/date_time_fwd.hpp"
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+class execution_context;
+
+template <typename T, typename Executor>
+class executor_binder;
+
+template <typename Executor>
+class executor_work_guard;
+
+class system_executor;
+
+class executor;
+
+template <typename Executor>
+class strand;
+
+class io_context;
+
+template <typename Clock>
+struct wait_traits;
+
+#if defined(ASIO_HAS_BOOST_DATE_TIME)
+
+template <typename Time>
+struct time_traits;
+
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
+template <typename Clock, typename WaitTraits>
+class waitable_timer_service;
+
+#if defined(ASIO_HAS_BOOST_DATE_TIME)
+
+template <typename TimeType, typename TimeTraits>
+class deadline_timer_service;
+
+#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
+
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+#if !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
+#define ASIO_BASIC_WAITABLE_TIMER_FWD_DECL
+
+template <typename Clock,
+    typename WaitTraits = asio::wait_traits<Clock>
+    ASIO_SVC_TPARAM_DEF2(= waitable_timer_service<Clock, WaitTraits>)>
+class basic_waitable_timer;
+
+#endif // !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
+
+#if defined(ASIO_HAS_CHRONO)
+
+typedef basic_waitable_timer<chrono::system_clock> system_timer;
+
+typedef basic_waitable_timer<chrono::steady_clock> steady_timer;
+
+typedef basic_waitable_timer<chrono::high_resolution_clock>
+  high_resolution_timer;
+
+#endif // defined(ASIO_HAS_CHRONO)
+
+template <class Protocol ASIO_SVC_TPARAM>
+class basic_socket;
+
+template <typename Protocol ASIO_SVC_TPARAM>
+class basic_datagram_socket;
+
+template <typename Protocol ASIO_SVC_TPARAM>
+class basic_stream_socket;
+
+template <typename Protocol ASIO_SVC_TPARAM>
+class basic_socket_acceptor;
+
+#if !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
+#define ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= stream_socket_service<Protocol>),
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
+    typename Clock = boost::posix_time::ptime,
+    typename WaitTraits = time_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF2(= deadline_timer_service<Clock, WaitTraits>)>
+#else
+    typename Clock = chrono::steady_clock,
+    typename WaitTraits = wait_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF1(= steady_timer::service_type)>
+#endif
+class basic_socket_streambuf;
+
+#endif // !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
+
+#if !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
+#define ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Protocol
+    ASIO_SVC_TPARAM_DEF1(= stream_socket_service<Protocol>),
+#if defined(ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
+    typename Clock = boost::posix_time::ptime,
+    typename WaitTraits = time_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF2(= deadline_timer_service<Clock, WaitTraits>)>
+#else
+    typename Clock = chrono::steady_clock,
+    typename WaitTraits = wait_traits<Clock>
+    ASIO_SVC_TPARAM1_DEF1(= steady_timer::service_type)>
+#endif
+class basic_socket_iostream;
+
+#endif // !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
+
+namespace ip {
+
+class address;
+
+class address_v4;
+
+class address_v6;
+
+template <typename Address>
+class basic_address_iterator;
+
+typedef basic_address_iterator<address_v4> address_v4_iterator;
+
+typedef basic_address_iterator<address_v6> address_v6_iterator;
+
+template <typename Address>
+class basic_address_range;
+
+typedef basic_address_range<address_v4> address_v4_range;
+
+typedef basic_address_range<address_v6> address_v6_range;
+
+class network_v4;
+
+class network_v6;
+
+template <typename InternetProtocol>
+class basic_endpoint;
+
+template <typename InternetProtocol>
+class basic_resolver_entry;
+
+template <typename InternetProtocol>
+class basic_resolver_results;
+
+template <typename InternetProtocol ASIO_SVC_TPARAM>
+class basic_resolver;
+
+class tcp;
+
+class udp;
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+#endif // ASIO_TS_NETFWD_HPP
diff --git a/extern/include/asio/ts/socket.hpp b/extern/include/asio/ts/socket.hpp
new file mode 100644
index 00000000..a5427348
--- /dev/null
+++ b/extern/include/asio/ts/socket.hpp
@@ -0,0 +1,27 @@
+//
+// ts/socket.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_SOCKET_HPP
+#define ASIO_TS_SOCKET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/socket_base.hpp"
+#include "asio/basic_socket.hpp"
+#include "asio/basic_datagram_socket.hpp"
+#include "asio/basic_stream_socket.hpp"
+#include "asio/basic_socket_acceptor.hpp"
+#include "asio/basic_socket_streambuf.hpp"
+#include "asio/basic_socket_iostream.hpp"
+#include "asio/connect.hpp"
+
+#endif // ASIO_TS_SOCKET_HPP
diff --git a/extern/include/asio/ts/timer.hpp b/extern/include/asio/ts/timer.hpp
new file mode 100644
index 00000000..872be8bf
--- /dev/null
+++ b/extern/include/asio/ts/timer.hpp
@@ -0,0 +1,26 @@
+//
+// ts/timer.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_TS_TIMER_HPP
+#define ASIO_TS_TIMER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/chrono.hpp"
+
+#include "asio/wait_traits.hpp"
+#include "asio/basic_waitable_timer.hpp"
+#include "asio/system_timer.hpp"
+#include "asio/steady_timer.hpp"
+#include "asio/high_resolution_timer.hpp"
+
+#endif // ASIO_TS_TIMER_HPP
diff --git a/extern/include/asio/unyield.hpp b/extern/include/asio/unyield.hpp
index 50ff8cf1..de3ed027 100644
--- a/extern/include/asio/unyield.hpp
+++ b/extern/include/asio/unyield.hpp
@@ -2,7 +2,7 @@
 // unyield.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/extern/include/asio/use_future.hpp b/extern/include/asio/use_future.hpp
index 1428bccd..3f9c6968 100644
--- a/extern/include/asio/use_future.hpp
+++ b/extern/include/asio/use_future.hpp
@@ -2,7 +2,7 @@
 // use_future.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,25 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_STD_FUTURE) \
+  || defined(GENERATING_DOCUMENTATION)
+
 #include <memory>
+#include "asio/detail/type_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
+namespace detail {
+
+template <typename Function, typename Allocator>
+class packaged_token;
+
+template <typename Function, typename Allocator, typename Result>
+class packaged_handler;
+
+} // namespace detail
 
 /// Class used to specify that an asynchronous operation should return a future.
 /**
@@ -56,12 +70,21 @@ class use_future_t
   {
   }
 
-  /// Specify an alternate allocator.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use rebind().) Specify an alternate allocator.
   template <typename OtherAllocator>
   use_future_t<OtherAllocator> operator[](const OtherAllocator& allocator) const
   {
     return use_future_t<OtherAllocator>(allocator);
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Specify an alternate allocator.
+  template <typename OtherAllocator>
+  use_future_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
+  {
+    return use_future_t<OtherAllocator>(allocator);
+  }
 
   /// Obtain allocator.
   allocator_type get_allocator() const
@@ -69,8 +92,49 @@ class use_future_t
     return allocator_;
   }
 
+  /// Wrap a function object in a packaged task.
+  /**
+   * The @c package function is used to adapt a function object as a packaged
+   * task. When this adapter is passed as a completion token to an asynchronous
+   * operation, the result of the function object is retuned via a std::future.
+   *
+   * @par Example
+   *
+   * @code std::future<std::size_t> fut =
+   *   my_socket.async_read_some(buffer,
+   *     use_future([](asio::error_code ec, std::size_t n)
+   *       {
+   *         return ec ? 0 : n;
+   *       }));
+   * ...
+   * std::size_t n = fut.get(); @endcode
+   */
+  template <typename Function>
+#if defined(GENERATING_DOCUMENTATION)
+  unspecified
+#else // defined(GENERATING_DOCUMENTATION)
+  detail::packaged_token<typename decay<Function>::type, Allocator>
+#endif // defined(GENERATING_DOCUMENTATION)
+  operator()(ASIO_MOVE_ARG(Function) f) const;
+
 private:
-  Allocator allocator_;
+  // Helper type to ensure that use_future can be constexpr default-constructed
+  // even when std::allocator<void> can't be.
+  struct std_allocator_void
+  {
+    ASIO_CONSTEXPR std_allocator_void()
+    {
+    }
+
+    operator std::allocator<void>() const
+    {
+      return std::allocator<void>();
+    }
+  };
+
+  typename conditional<
+    is_same<std::allocator<void>, Allocator>::value,
+    std_allocator_void, Allocator>::type allocator_;
 };
 
 /// A special value, similar to std::nothrow.
@@ -89,4 +153,7 @@ __declspec(selectany) use_future_t<> use_future;
 
 #include "asio/impl/use_future.hpp"
 
+#endif // defined(ASIO_HAS_STD_FUTURE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
 #endif // ASIO_USE_FUTURE_HPP
diff --git a/extern/include/asio/uses_executor.hpp b/extern/include/asio/uses_executor.hpp
new file mode 100644
index 00000000..e985c282
--- /dev/null
+++ b/extern/include/asio/uses_executor.hpp
@@ -0,0 +1,71 @@
+//
+// uses_executor.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_USES_EXECUTOR_HPP
+#define ASIO_USES_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// A special type, similar to std::nothrow_t, used to disambiguate
+/// constructors that accept executor arguments.
+/**
+ * The executor_arg_t struct is an empty structure type used as a unique type
+ * to disambiguate constructor and function overloading. Specifically, some
+ * types have constructors with executor_arg_t as the first argument,
+ * immediately followed by an argument of a type that satisfies the Executor
+ * type requirements.
+ */
+struct executor_arg_t
+{
+  /// Constructor.
+  ASIO_CONSTEXPR executor_arg_t() ASIO_NOEXCEPT
+  {
+  }
+};
+
+/// A special value, similar to std::nothrow, used to disambiguate constructors
+/// that accept executor arguments.
+/**
+ * See asio::executor_arg_t and asio::uses_executor
+ * for more information.
+ */
+#if defined(ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
+constexpr executor_arg_t executor_arg;
+#elif defined(ASIO_MSVC)
+__declspec(selectany) executor_arg_t executor_arg;
+#endif
+
+/// The uses_executor trait detects whether a type T has an associated executor
+/// that is convertible from type Executor.
+/**
+ * Meets the BinaryTypeTrait requirements. The Asio library provides a
+ * definition that is derived from false_type. A program may specialize this
+ * template to derive from true_type for a user-defined type T that can be
+ * constructed with an executor, where the first argument of a constructor has
+ * type executor_arg_t and the second argument is convertible from type
+ * Executor.
+ */
+template <typename T, typename Executor>
+struct uses_executor : false_type {};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_USES_EXECUTOR_HPP
diff --git a/extern/include/asio/version.hpp b/extern/include/asio/version.hpp
index b03da6bd..099ffdbd 100644
--- a/extern/include/asio/version.hpp
+++ b/extern/include/asio/version.hpp
@@ -2,7 +2,7 @@
 // version.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,6 +18,6 @@
 // ASIO_VERSION % 100 is the sub-minor version
 // ASIO_VERSION / 100 % 1000 is the minor version
 // ASIO_VERSION / 100000 is the major version
-#define ASIO_VERSION 101006 // 1.10.6
+#define ASIO_VERSION 101201 // 1.12.1
 
 #endif // ASIO_VERSION_HPP
diff --git a/extern/include/asio/wait_traits.hpp b/extern/include/asio/wait_traits.hpp
index de2c10d2..a6016f7c 100644
--- a/extern/include/asio/wait_traits.hpp
+++ b/extern/include/asio/wait_traits.hpp
@@ -2,7 +2,7 @@
 // wait_traits.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -24,7 +24,7 @@ template <typename Clock>
 struct wait_traits
 {
   /// Convert a clock duration into a duration used for waiting.
-  /** 
+  /**
    * @returns @c d.
    */
   static typename Clock::duration to_wait_duration(
@@ -32,6 +32,21 @@ struct wait_traits
   {
     return d;
   }
+
+  /// Convert a clock duration into a duration used for waiting.
+  /**
+   * @returns @c d.
+   */
+  static typename Clock::duration to_wait_duration(
+      const typename Clock::time_point& t)
+  {
+    typename Clock::time_point now = Clock::now();
+    if (now + (Clock::duration::max)() < t)
+      return (Clock::duration::max)();
+    if (now + (Clock::duration::min)() > t)
+      return (Clock::duration::min)();
+    return t - now;
+  }
 };
 
 } // namespace asio
diff --git a/extern/include/asio/waitable_timer_service.hpp b/extern/include/asio/waitable_timer_service.hpp
index 92d971eb..75e496f8 100644
--- a/extern/include/asio/waitable_timer_service.hpp
+++ b/extern/include/asio/waitable_timer_service.hpp
@@ -2,7 +2,7 @@
 // waitable_timer_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #include <cstddef>
 #include "asio/async_result.hpp"
 #include "asio/detail/chrono_time_traits.hpp"
 #include "asio/detail/deadline_timer_service.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 #include "asio/wait_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -32,7 +35,7 @@ template <typename Clock,
     typename WaitTraits = asio::wait_traits<Clock> >
 class waitable_timer_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<
       waitable_timer_service<Clock, WaitTraits> >
@@ -41,7 +44,7 @@ class waitable_timer_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
   /// The clock type.
@@ -69,11 +72,11 @@ class waitable_timer_service
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// Construct a new timer service for the specified io_service.
-  explicit waitable_timer_service(asio::io_service& io_service)
+  /// Construct a new timer service for the specified io_context.
+  explicit waitable_timer_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        waitable_timer_service<Clock, WaitTraits> >(io_service),
-      service_impl_(io_service)
+        waitable_timer_service<Clock, WaitTraits> >(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -89,6 +92,23 @@ class waitable_timer_service
     service_impl_.destroy(impl);
   }
 
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a new timer implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_construct(impl, other_impl);
+  }
+
+  /// Move-assign from another timer implementation.
+  void move_assign(implementation_type& impl,
+      waitable_timer_service& other_service,
+      implementation_type& other_impl)
+  {
+    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
   /// Cancel any asynchronous wait operations associated with the timer.
   std::size_t cancel(implementation_type& impl, asio::error_code& ec)
   {
@@ -102,10 +122,19 @@ class waitable_timer_service
     return service_impl_.cancel_one(impl, ec);
   }
 
-  /// Get the expiry time for the timer as an absolute time.
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use expiry().) Get the expiry time for the timer as an
+  /// absolute time.
   time_point expires_at(const implementation_type& impl) const
   {
-    return service_impl_.expires_at(impl);
+    return service_impl_.expiry(impl);
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the expiry time for the timer as an absolute time.
+  time_point expiry(const implementation_type& impl) const
+  {
+    return service_impl_.expiry(impl);
   }
 
   /// Set the expiry time for the timer as an absolute time.
@@ -115,18 +144,30 @@ class waitable_timer_service
     return service_impl_.expires_at(impl, expiry_time, ec);
   }
 
-  /// Get the expiry time for the timer relative to now.
+  /// Set the expiry time for the timer relative to now.
+  std::size_t expires_after(implementation_type& impl,
+      const duration& expiry_time, asio::error_code& ec)
+  {
+    return service_impl_.expires_after(impl, expiry_time, ec);
+  }
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use expiry().) Get the expiry time for the timer relative to
+  /// now.
   duration expires_from_now(const implementation_type& impl) const
   {
-    return service_impl_.expires_from_now(impl);
+    typedef detail::chrono_time_traits<Clock, WaitTraits> traits;
+    return traits::subtract(service_impl_.expiry(impl), traits::now());
   }
 
-  /// Set the expiry time for the timer relative to now.
+  /// (Deprecated: Use expires_after().) Set the expiry time for the timer
+  /// relative to now.
   std::size_t expires_from_now(implementation_type& impl,
       const duration& expiry_time, asio::error_code& ec)
   {
-    return service_impl_.expires_from_now(impl, expiry_time, ec);
+    return service_impl_.expires_after(impl, expiry_time, ec);
   }
+#endif // !defined(ASIO_NO_DEPRECATED)
 
   // Perform a blocking wait on the timer.
   void wait(implementation_type& impl, asio::error_code& ec)
@@ -141,20 +182,19 @@ class waitable_timer_service
   async_wait(implementation_type& impl,
       ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    detail::async_result_init<
-      WaitHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(WaitHandler)(handler));
+    async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
 
-    service_impl_.async_wait(impl, init.handler);
+    service_impl_.async_wait(impl, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -165,4 +205,6 @@ class waitable_timer_service
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WAITABLE_TIMER_SERVICE_HPP
diff --git a/extern/include/asio/windows/basic_handle.hpp b/extern/include/asio/windows/basic_handle.hpp
index 2278fc73..f7c9d0d0 100644
--- a/extern/include/asio/windows/basic_handle.hpp
+++ b/extern/include/asio/windows/basic_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
   || defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
@@ -45,10 +47,6 @@ 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_handle_type native_handle_type;
 
@@ -59,11 +57,11 @@ class basic_handle
   /**
    * This constructor creates a handle without opening it.
    *
-   * @param io_service The io_service object that the handle will use to
+   * @param io_context The io_context object that the handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    */
-  explicit basic_handle(asio::io_service& io_service)
-    : basic_io_object<HandleService>(io_service)
+  explicit basic_handle(asio::io_context& io_context)
+    : basic_io_object<HandleService>(io_context)
   {
   }
 
@@ -71,16 +69,16 @@ class basic_handle
   /**
    * This constructor creates a handle object to hold an existing native handle.
    *
-   * @param io_service The io_service object that the handle will use to
+   * @param io_context The io_context object that the handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    *
    * @param handle A native handle.
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_handle(asio::io_service& io_service,
+  basic_handle(asio::io_context& io_context,
       const native_handle_type& handle)
-    : basic_io_object<HandleService>(io_service)
+    : basic_io_object<HandleService>(io_context)
   {
     asio::error_code ec;
     this->get_service().assign(this->get_implementation(), handle, ec);
@@ -95,7 +93,7 @@ class basic_handle
    * @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.
+   * constructed using the @c basic_handle(io_context&) constructor.
    */
   basic_handle(basic_handle&& other)
     : basic_io_object<HandleService>(
@@ -110,7 +108,7 @@ class basic_handle
    * @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.
+   * constructed using the @c basic_handle(io_context&) constructor.
    */
   basic_handle& operator=(basic_handle&& other)
   {
@@ -171,10 +169,11 @@ class basic_handle
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code assign(const native_handle_type& handle,
+  ASIO_SYNC_OP_VOID assign(const native_handle_type& handle,
       asio::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(), handle, ec);
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the handle is open.
@@ -206,20 +205,10 @@ class basic_handle
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code close(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (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
-   * that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->get_service().native_handle(this->get_implementation());
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native handle representation.
@@ -256,9 +245,10 @@ class basic_handle
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  asio::error_code cancel(asio::error_code& ec)
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
 protected:
@@ -278,4 +268,6 @@ class basic_handle
        //   || defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WINDOWS_BASIC_HANDLE_HPP
diff --git a/extern/include/asio/windows/basic_object_handle.hpp b/extern/include/asio/windows/basic_object_handle.hpp
index 314badce..4b296846 100644
--- a/extern/include/asio/windows/basic_object_handle.hpp
+++ b/extern/include/asio/windows/basic_object_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_object_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -18,6 +18,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -52,11 +54,11 @@ class basic_object_handle
   /**
    * This constructor creates an object handle without opening it.
    *
-   * @param io_service The io_service object that the object handle will use to
+   * @param io_context The io_context object that the object handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    */
-  explicit basic_object_handle(asio::io_service& io_service)
-    : basic_handle<ObjectHandleService>(io_service)
+  explicit basic_object_handle(asio::io_context& io_context)
+    : basic_handle<ObjectHandleService>(io_context)
   {
   }
 
@@ -65,16 +67,16 @@ class basic_object_handle
    * This constructor creates an object handle object to hold an existing native
    * handle.
    *
-   * @param io_service The io_service object that the object handle will use to
+   * @param io_context The io_context object that the object handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    *
    * @param native_handle The new underlying handle implementation.
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_object_handle(asio::io_service& io_service,
+  basic_object_handle(asio::io_context& io_context,
       const native_handle_type& native_handle)
-    : basic_handle<ObjectHandleService>(io_service, native_handle)
+    : basic_handle<ObjectHandleService>(io_context, native_handle)
   {
   }
 
@@ -87,7 +89,7 @@ class basic_object_handle
    * occur.
    *
    * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_object_handle(io_service&) constructor.
+   * constructed using the @c basic_object_handle(io_context&) constructor.
    */
   basic_object_handle(basic_object_handle&& other)
     : basic_handle<ObjectHandleService>(
@@ -103,7 +105,7 @@ class basic_object_handle
    * occur.
    *
    * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_object_handle(io_service&) constructor.
+   * constructed using the @c basic_object_handle(io_context&) constructor.
    */
   basic_object_handle& operator=(basic_object_handle&& other)
   {
@@ -155,7 +157,7 @@ class basic_object_handle
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    */
   template <typename WaitHandler>
   ASIO_INITFN_RESULT_TYPE(WaitHandler,
@@ -175,4 +177,6 @@ class basic_object_handle
 #endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
diff --git a/extern/include/asio/windows/basic_random_access_handle.hpp b/extern/include/asio/windows/basic_random_access_handle.hpp
index 6b7f4fc2..42269773 100644
--- a/extern/include/asio/windows/basic_random_access_handle.hpp
+++ b/extern/include/asio/windows/basic_random_access_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_random_access_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -46,10 +48,6 @@ 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_handle_type
     native_handle_type;
@@ -59,12 +57,12 @@ class basic_random_access_handle
    * This constructor creates a random-access handle without opening it. The
    * handle needs to be opened before data can be written to or read from it.
    *
-   * @param io_service The io_service object that the random-access handle will
+   * @param io_context The io_context object that the random-access handle will
    * use to dispatch handlers for any asynchronous operations performed on the
    * handle.
    */
-  explicit basic_random_access_handle(asio::io_service& io_service)
-    : basic_handle<RandomAccessHandleService>(io_service)
+  explicit basic_random_access_handle(asio::io_context& io_context)
+    : basic_handle<RandomAccessHandleService>(io_context)
   {
   }
 
@@ -73,7 +71,7 @@ class basic_random_access_handle
    * This constructor creates a random-access handle object to hold an existing
    * native handle.
    *
-   * @param io_service The io_service object that the random-access handle will
+   * @param io_context The io_context object that the random-access handle will
    * use to dispatch handlers for any asynchronous operations performed on the
    * handle.
    *
@@ -81,9 +79,9 @@ class basic_random_access_handle
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_random_access_handle(asio::io_service& io_service,
+  basic_random_access_handle(asio::io_context& io_context,
       const native_handle_type& handle)
-    : basic_handle<RandomAccessHandleService>(io_service, handle)
+    : basic_handle<RandomAccessHandleService>(io_context, handle)
   {
   }
 
@@ -96,7 +94,7 @@ class basic_random_access_handle
    * 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&)
+   * constructed using the @c basic_random_access_handle(io_context&)
    * constructor.
    */
   basic_random_access_handle(basic_random_access_handle&& other)
@@ -114,7 +112,7 @@ class basic_random_access_handle
    * 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&)
+   * constructed using the @c basic_random_access_handle(io_context&)
    * constructor.
    */
   basic_random_access_handle& operator=(basic_random_access_handle&& other)
@@ -213,7 +211,7 @@ class basic_random_access_handle
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write_at function if you need to ensure that
@@ -333,7 +331,7 @@ class basic_random_access_handle
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read_at function if you need to ensure that
@@ -373,4 +371,6 @@ class basic_random_access_handle
 #endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
diff --git a/extern/include/asio/windows/basic_stream_handle.hpp b/extern/include/asio/windows/basic_stream_handle.hpp
index 388b1e53..3bfce688 100644
--- a/extern/include/asio/windows/basic_stream_handle.hpp
+++ b/extern/include/asio/windows/basic_stream_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_stream_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -49,10 +51,6 @@ 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_handle_type native_handle_type;
 
@@ -62,11 +60,11 @@ class basic_stream_handle
    * 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 stream handle will use to
+   * @param io_context The io_context object that the stream handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    */
-  explicit basic_stream_handle(asio::io_service& io_service)
-    : basic_handle<StreamHandleService>(io_service)
+  explicit basic_stream_handle(asio::io_context& io_context)
+    : basic_handle<StreamHandleService>(io_context)
   {
   }
 
@@ -75,16 +73,16 @@ class basic_stream_handle
    * This constructor creates a stream handle object to hold an existing native
    * handle.
    *
-   * @param io_service The io_service object that the stream handle will use to
+   * @param io_context The io_context object that the stream handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    *
    * @param handle The new underlying handle implementation.
    *
    * @throws asio::system_error Thrown on failure.
    */
-  basic_stream_handle(asio::io_service& io_service,
+  basic_stream_handle(asio::io_context& io_context,
       const native_handle_type& handle)
-    : basic_handle<StreamHandleService>(io_service, handle)
+    : basic_handle<StreamHandleService>(io_context, handle)
   {
   }
 
@@ -97,7 +95,7 @@ class basic_stream_handle
    * 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.
+   * constructed using the @c basic_stream_handle(io_context&) constructor.
    */
   basic_stream_handle(basic_stream_handle&& other)
     : basic_handle<StreamHandleService>(
@@ -114,7 +112,7 @@ class basic_stream_handle
    * 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.
+   * constructed using the @c basic_stream_handle(io_context&) constructor.
    */
   basic_stream_handle& operator=(basic_stream_handle&& other)
   {
@@ -205,7 +203,7 @@ class basic_stream_handle
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
@@ -317,7 +315,7 @@ class basic_stream_handle
    * 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
-   * asio::io_service::post().
+   * asio::io_context::post().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
@@ -356,4 +354,6 @@ class basic_stream_handle
 #endif // defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
diff --git a/extern/include/asio/windows/object_handle.hpp b/extern/include/asio/windows/object_handle.hpp
index f4162e1a..581b5680 100644
--- a/extern/include/asio/windows/object_handle.hpp
+++ b/extern/include/asio/windows/object_handle.hpp
@@ -2,7 +2,7 @@
 // windows/object_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -21,17 +21,360 @@
 #if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
-#include "asio/windows/basic_object_handle.hpp"
+#include "asio/async_result.hpp"
+#include "asio/basic_io_object.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/win_object_handle_service.hpp"
+#include "asio/error.hpp"
+#include "asio/io_context.hpp"
+
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/windows/basic_object_handle.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+#define ASIO_SVC_T asio::detail::win_object_handle_service
+
+#include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace windows {
 
-/// Typedef for the typical usage of an object handle.
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+// Typedef for the typical usage of an object handle.
 typedef basic_object_handle<> object_handle;
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+/// Provides object-oriented handle functionality.
+/**
+ * The windows::object_handle class provides asynchronous and blocking
+ * object-oriented handle functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class object_handle
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
+  /// The native representation of a handle.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef ASIO_SVC_T::native_handle_type native_handle_type;
+#endif
+
+  /// An object_handle is always the lowest layer.
+  typedef object_handle lowest_layer_type;
+
+  /// Construct an object_handle without opening it.
+  /**
+   * This constructor creates an object handle without opening it.
+   *
+   * @param io_context The io_context object that the object handle will use to
+   * dispatch handlers for any asynchronous operations performed on the handle.
+   */
+  explicit object_handle(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+  }
+
+  /// Construct an object_handle on an existing native handle.
+  /**
+   * This constructor creates an object handle object to hold an existing native
+   * handle.
+   *
+   * @param io_context The io_context object that the object handle will use to
+   * dispatch handlers for any asynchronous operations performed on the handle.
+   *
+   * @param native_handle The new underlying handle implementation.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  object_handle(asio::io_context& io_context,
+      const native_handle_type& native_handle)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(), native_handle, ec);
+    asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct an object_handle from another.
+  /**
+   * This constructor moves an object handle from one object to another.
+   *
+   * @param other The other object_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 object_handle(io_context&) constructor.
+   */
+  object_handle(object_handle&& other)
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
+  {
+  }
+
+  /// Move-assign an object_handle from another.
+  /**
+   * This assignment operator moves an object handle from one object to another.
+   *
+   * @param other The other object_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 object_handle(io_context&) constructor.
+   */
+  object_handle& operator=(object_handle&& other)
+  {
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since an object_handle cannot contain any further layers, it simply
+   * returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since an object_handle cannot contain any further layers, it simply
+   * returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Assign an existing native handle to the handle.
+  /*
+   * This function opens the handle to hold an existing native handle.
+   *
+   * @param handle A native handle.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& handle)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    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 handle A native handle.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID assign(const native_handle_type& handle,
+      asio::error_code& ec)
+  {
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the handle is open.
+  bool is_open() const
+  {
+    return this->get_service().is_open(this->get_implementation());
+  }
+
+  /// Close the handle.
+  /**
+   * This function is used to close the handle. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void close()
+  {
+    asio::error_code ec;
+    this->get_service().close(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the handle.
+  /**
+   * This function is used to close the handle. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
+  {
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// 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.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    asio::error_code ec;
+    this->get_service().cancel(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the handle.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
+  {
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Perform a blocking wait on the object handle.
+  /**
+   * This function is used to wait for the object handle to be set to the
+   * signalled state. This function blocks and does not return until the object
+   * handle has been set to the signalled state.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void wait()
+  {
+    asio::error_code ec;
+    this->get_service().wait(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "wait");
+  }
+
+  /// Perform a blocking wait on the object handle.
+  /**
+   * This function is used to wait for the object handle to be set to the
+   * signalled state. This function blocks and does not return until the object
+   * handle has been set to the signalled state.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  void wait(asio::error_code& ec)
+  {
+    this->get_service().wait(this->get_implementation(), ec);
+  }
+
+  /// Start an asynchronous wait on the object handle.
+  /**
+   * This function is be used to initiate an asynchronous wait against the
+   * object handle. It always returns immediately.
+   *
+   * @param handler The handler to be called when the object handle is set to
+   * the signalled state. Copies will be made of the handler as required. The
+   * function signature of the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error // Result of operation.
+   * ); @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
+   * asio::io_context::post().
+   */
+  template <typename WaitHandler>
+  ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (asio::error_code))
+  async_wait(ASIO_MOVE_ARG(WaitHandler) handler)
+  {
+    asio::async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
+
+    this->get_service().async_wait(this->get_implementation(),
+        init.completion_handler);
+
+    return init.result.get();
+  }
+};
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 } // namespace windows
 } // namespace asio
 
+#include "asio/detail/pop_options.hpp"
+
+#undef ASIO_SVC_T
+
 #endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
diff --git a/extern/include/asio/windows/object_handle_service.hpp b/extern/include/asio/windows/object_handle_service.hpp
index d066b170..95436d79 100644
--- a/extern/include/asio/windows/object_handle_service.hpp
+++ b/extern/include/asio/windows/object_handle_service.hpp
@@ -2,7 +2,7 @@
 // windows/object_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -18,13 +18,15 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include "asio/async_result.hpp"
 #include "asio/detail/win_object_handle_service.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -34,7 +36,7 @@ namespace windows {
 /// Default service implementation for an object handle.
 class object_handle_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<object_handle_service>
 #endif
@@ -42,7 +44,7 @@ class object_handle_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
 private:
@@ -64,10 +66,10 @@ class object_handle_service
   typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new object handle service for the specified io_service.
-  explicit object_handle_service(asio::io_service& io_service)
-    : asio::detail::service_base<object_handle_service>(io_service),
-      service_impl_(io_service)
+  /// Construct a new object handle service for the specified io_context.
+  explicit object_handle_service(asio::io_context& io_context)
+    : asio::detail::service_base<object_handle_service>(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -101,10 +103,11 @@ class object_handle_service
   }
 
   /// Assign an existing native handle to an object handle.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const native_handle_type& handle, asio::error_code& ec)
   {
-    return service_impl_.assign(impl, handle, ec);
+    service_impl_.assign(impl, handle, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the handle is open.
@@ -114,10 +117,11 @@ class object_handle_service
   }
 
   /// Close an object handle implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native handle implementation.
@@ -127,10 +131,11 @@ class object_handle_service
   }
 
   /// Cancel all asynchronous operations associated with the handle.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   // Wait for a signaled state.
@@ -146,20 +151,19 @@ class object_handle_service
   async_wait(implementation_type& impl,
       ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    asio::detail::async_result_init<
-      WaitHandler, void (asio::error_code)> init(
-        ASIO_MOVE_CAST(WaitHandler)(handler));
+    asio::async_completion<WaitHandler,
+      void (asio::error_code)> init(handler);
 
-    service_impl_.async_wait(impl, init.handler);
+    service_impl_.async_wait(impl, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -174,4 +178,6 @@ class object_handle_service
 #endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WINDOWS_OBJECT_HANDLE_SERVICE_HPP
diff --git a/extern/include/asio/windows/overlapped_handle.hpp b/extern/include/asio/windows/overlapped_handle.hpp
new file mode 100644
index 00000000..3d479ba6
--- /dev/null
+++ b/extern/include/asio/windows/overlapped_handle.hpp
@@ -0,0 +1,331 @@
+//
+// windows/overlapped_handle.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_WINDOWS_OVERLAPPED_HANDLE_HPP
+#define ASIO_WINDOWS_OVERLAPPED_HANDLE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_ENABLE_OLD_SERVICES)
+
+#if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
+  || defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <cstddef>
+#include "asio/async_result.hpp"
+#include "asio/basic_io_object.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/win_iocp_handle_service.hpp"
+#include "asio/error.hpp"
+#include "asio/io_context.hpp"
+
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#define ASIO_SVC_T asio::detail::win_iocp_handle_service
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace windows {
+
+/// Provides Windows handle functionality for objects that support
+/// overlapped I/O.
+/**
+ * The windows::overlapped_handle class provides the ability to wrap a Windows
+ * handle. The underlying object referred to by the handle must support
+ * overlapped I/O.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class overlapped_handle
+  : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef io_context::executor_type executor_type;
+
+  /// The native representation of a handle.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef ASIO_SVC_T::native_handle_type native_handle_type;
+#endif
+
+  /// An overlapped_handle is always the lowest layer.
+  typedef overlapped_handle lowest_layer_type;
+
+  /// Construct an overlapped_handle without opening it.
+  /**
+   * This constructor creates a handle without opening it.
+   *
+   * @param io_context The io_context object that the handle will use to
+   * dispatch handlers for any asynchronous operations performed on the handle.
+   */
+  explicit overlapped_handle(asio::io_context& io_context)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+  }
+
+  /// Construct an overlapped_handle on an existing native handle.
+  /**
+   * This constructor creates a handle object to hold an existing native handle.
+   *
+   * @param io_context The io_context object that the handle will use to
+   * dispatch handlers for any asynchronous operations performed on the handle.
+   *
+   * @param handle A native handle.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  overlapped_handle(asio::io_context& io_context,
+      const native_handle_type& handle)
+    : basic_io_object<ASIO_SVC_T>(io_context)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct an overlapped_handle from another.
+  /**
+   * This constructor moves a handle from one object to another.
+   *
+   * @param other The other overlapped_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 overlapped_handle(io_context&) constructor.
+   */
+  overlapped_handle(overlapped_handle&& other)
+    : basic_io_object<ASIO_SVC_T>(std::move(other))
+  {
+  }
+
+  /// Move-assign an overlapped_handle from another.
+  /**
+   * This assignment operator moves a handle from one object to another.
+   *
+   * @param other The other overlapped_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 overlapped_handle(io_context&) constructor.
+   */
+  overlapped_handle& operator=(overlapped_handle&& other)
+  {
+    basic_io_object<ASIO_SVC_T>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(ASIO_NO_DEPRECATED)
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_context()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_context();
+  }
+
+  /// (Deprecated: Use get_executor().) Get the io_context associated with the
+  /// object.
+  /**
+   * This function may be used to obtain the io_context object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_context object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  asio::io_context& get_io_service()
+  {
+    return basic_io_object<ASIO_SVC_T>::get_io_service();
+  }
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() ASIO_NOEXCEPT
+  {
+    return basic_io_object<ASIO_SVC_T>::get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since an overlapped_handle cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since an overlapped_handle cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Assign an existing native handle to the handle.
+  /*
+   * This function opens the handle to hold an existing native handle.
+   *
+   * @param handle A native handle.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& handle)
+  {
+    asio::error_code ec;
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    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 handle A native handle.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID assign(const native_handle_type& handle,
+      asio::error_code& ec)
+  {
+    this->get_service().assign(this->get_implementation(), handle, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the handle is open.
+  bool is_open() const
+  {
+    return this->get_service().is_open(this->get_implementation());
+  }
+
+  /// Close the handle.
+  /**
+   * This function is used to close the handle. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void close()
+  {
+    asio::error_code ec;
+    this->get_service().close(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the handle.
+  /**
+   * This function is used to close the handle. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
+  {
+    this->get_service().close(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// 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.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    asio::error_code ec;
+    this->get_service().cancel(this->get_implementation(), ec);
+    asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the handle.
+  /**
+   * This function causes all outstanding asynchronous read or write operations
+   * to finish immediately, and the handlers for cancelled operations will be
+   * passed the asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
+  {
+    this->get_service().cancel(this->get_implementation(), ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  /**
+   * This function destroys the handle, cancelling any outstanding asynchronous
+   * wait operations associated with the handle as if by calling @c cancel.
+   */
+  ~overlapped_handle()
+  {
+  }
+};
+
+} // namespace windows
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#undef ASIO_SVC_T
+
+#endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
+       //   || defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // !defined(ASIO_ENABLE_OLD_SERVICES)
+
+#endif // ASIO_WINDOWS_OVERLAPPED_HANDLE_HPP
diff --git a/extern/include/asio/windows/overlapped_ptr.hpp b/extern/include/asio/windows/overlapped_ptr.hpp
index 284b740b..ce0b2a42 100644
--- a/extern/include/asio/windows/overlapped_ptr.hpp
+++ b/extern/include/asio/windows/overlapped_ptr.hpp
@@ -2,7 +2,7 @@
 // windows/overlapped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,7 +22,7 @@
 
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/win_iocp_overlapped_ptr.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -50,9 +50,9 @@ class overlapped_ptr
 
   /// Construct an overlapped_ptr to contain the specified handler.
   template <typename Handler>
-  explicit overlapped_ptr(asio::io_service& io_service,
+  explicit overlapped_ptr(asio::io_context& io_context,
       ASIO_MOVE_ARG(Handler) handler)
-    : impl_(io_service, ASIO_MOVE_CAST(Handler)(handler))
+    : impl_(io_context, ASIO_MOVE_CAST(Handler)(handler))
   {
   }
 
@@ -70,10 +70,10 @@ class overlapped_ptr
   /// Reset to contain the specified handler, freeing any current OVERLAPPED
   /// object.
   template <typename Handler>
-  void reset(asio::io_service& io_service,
+  void reset(asio::io_context& io_context,
       ASIO_MOVE_ARG(Handler) handler)
   {
-    impl_.reset(io_service, ASIO_MOVE_CAST(Handler)(handler));
+    impl_.reset(io_context, ASIO_MOVE_CAST(Handler)(handler));
   }
 
   /// Get the contained OVERLAPPED object.
diff --git a/extern/include/asio/windows/random_access_handle.hpp b/extern/include/asio/windows/random_access_handle.hpp
index 9677723d..301d5f8d 100644
--- a/extern/include/asio/windows/random_access_handle.hpp
+++ b/extern/include/asio/windows/random_access_handle.hpp
@@ -2,7 +2,7 @@
 // windows/random_access_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,21 +16,362 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/windows/overlapped_handle.hpp"
 
 #if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
-#include "asio/windows/basic_random_access_handle.hpp"
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/windows/basic_random_access_handle.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+#include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace windows {
 
-/// Typedef for the typical usage of a random-access handle.
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+// Typedef for the typical usage of a random-access handle.
 typedef basic_random_access_handle<> random_access_handle;
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+/// Provides random-access handle functionality.
+/**
+ * The windows::random_access_handle class provides asynchronous and
+ * blocking random-access handle functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class random_access_handle
+  : public overlapped_handle
+{
+public:
+  /// Construct a random_access_handle without opening it.
+  /**
+   * This constructor creates a random-access handle without opening it. The
+   * handle needs to be opened before data can be written to or read from it.
+   *
+   * @param io_context The io_context object that the random-access handle will
+   * use to dispatch handlers for any asynchronous operations performed on the
+   * handle.
+   */
+  explicit random_access_handle(asio::io_context& io_context)
+    : overlapped_handle(io_context)
+  {
+  }
+
+  /// Construct a random_access_handle on an existing native handle.
+  /**
+   * This constructor creates a random-access handle object to hold an existing
+   * native handle.
+   *
+   * @param io_context The io_context object that the random-access handle will
+   * use to dispatch handlers for any asynchronous operations performed on the
+   * handle.
+   *
+   * @param handle The new underlying handle implementation.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  random_access_handle(asio::io_context& io_context,
+      const native_handle_type& handle)
+    : overlapped_handle(io_context, handle)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a random_access_handle from another.
+  /**
+   * This constructor moves a random-access handle from one object to another.
+   *
+   * @param other The other 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 random_access_handle(io_context&)
+   * constructor.
+   */
+  random_access_handle(random_access_handle&& other)
+    : overlapped_handle(std::move(other))
+  {
+  }
+
+  /// Move-assign a random_access_handle from another.
+  /**
+   * This assignment operator moves a random-access handle from one object to
+   * another.
+   *
+   * @param other The other 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 random_access_handle(io_context&)
+   * constructor.
+   */
+  random_access_handle& operator=(random_access_handle&& other)
+  {
+    overlapped_handle::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(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
+   * function call will block until one or more bytes of the data has been
+   * written successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The write_some_at operation may not write all of the data. Consider
+   * using the @ref write_at function if you need to ensure that all data is
+   * written before the blocking operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.write_some_at(42, asio::buffer(data, size));
+   * @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.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().write_some_at(
+        this->get_implementation(), offset, buffers, ec);
+    asio::detail::throw_error(ec, "write_some_at");
+    return s;
+  }
+
+  /// Write some data to the handle at the specified offset.
+  /**
+   * This function is used to write data to the random-access handle. The
+   * function call will block until one or more bytes of the data has been
+   * written successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write_at function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers, asio::error_code& ec)
+  {
+    return this->get_service().write_some_at(
+        this->get_implementation(), offset, buffers, ec);
+  }
+
+  /// Start an asynchronous write at the specified offset.
+  /**
+   * This function is used to asynchronously write data to the random-access
+   * handle. The function call always returns immediately.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   * 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 handler The handler to be called when the write operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes written.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write_at function if you need to ensure that
+   * all data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_write_some_at(42, asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename ConstBufferSequence, typename WriteHandler>
+  ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (asio::error_code, std::size_t))
+  async_write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers,
+      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.
+    ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    asio::async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_write_some_at(this->get_implementation(),
+        offset, buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+
+  /// Read some data from the handle at the specified offset.
+  /**
+   * This function is used to read data from the random-access handle. The
+   * function call will block until one or more bytes of data has been read
+   * successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read_at function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.read_some_at(42, asio::buffer(data, size));
+   * @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.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().read_some_at(
+        this->get_implementation(), offset, buffers, ec);
+    asio::detail::throw_error(ec, "read_some_at");
+    return s;
+  }
+
+  /// Read some data from the handle at the specified offset.
+  /**
+   * This function is used to read data from the random-access handle. The
+   * function call will block until one or more bytes of data has been read
+   * successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read_at 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 read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers, asio::error_code& ec)
+  {
+    return this->get_service().read_some_at(
+        this->get_implementation(), offset, buffers, ec);
+  }
+
+  /// Start an asynchronous read at the specified offset.
+  /**
+   * This function is used to asynchronously read data from the random-access
+   * handle. The function call always returns immediately.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * 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 handler The handler to be called when the read operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes read.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read_at function if you need to ensure that
+   * the requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_read_some_at(42, asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename MutableBufferSequence, typename ReadHandler>
+  ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (asio::error_code, std::size_t))
+  async_read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers,
+      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.
+    ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    asio::async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_read_some_at(this->get_implementation(),
+        offset, buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+};
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 } // namespace windows
 } // namespace asio
 
+#include "asio/detail/pop_options.hpp"
+
 #endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
diff --git a/extern/include/asio/windows/random_access_handle_service.hpp b/extern/include/asio/windows/random_access_handle_service.hpp
index 1ae35be2..ebccf3e3 100644
--- a/extern/include/asio/windows/random_access_handle_service.hpp
+++ b/extern/include/asio/windows/random_access_handle_service.hpp
@@ -2,7 +2,7 @@
 // windows/random_access_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -25,7 +27,7 @@
 #include "asio/detail/cstdint.hpp"
 #include "asio/detail/win_iocp_handle_service.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -35,7 +37,7 @@ namespace windows {
 /// Default service implementation for a random-access handle.
 class random_access_handle_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<random_access_handle_service>
 #endif
@@ -43,7 +45,7 @@ class random_access_handle_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
 private:
@@ -58,13 +60,6 @@ class random_access_handle_service
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native handle type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_handle_type;
@@ -72,11 +67,11 @@ class random_access_handle_service
   typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new random-access handle service for the specified io_service.
-  explicit random_access_handle_service(asio::io_service& io_service)
+  /// Construct a new random-access handle service for the specified io_context.
+  explicit random_access_handle_service(asio::io_context& io_context)
     : asio::detail::service_base<
-        random_access_handle_service>(io_service),
-      service_impl_(io_service)
+        random_access_handle_service>(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -110,10 +105,11 @@ class random_access_handle_service
   }
 
   /// Assign an existing native handle to a random-access handle.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const native_handle_type& handle, asio::error_code& ec)
   {
-    return service_impl_.assign(impl, handle, ec);
+    service_impl_.assign(impl, handle, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the handle is open.
@@ -123,16 +119,11 @@ class random_access_handle_service
   }
 
   /// Close a random-access handle implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native handle implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native handle implementation.
@@ -142,10 +133,11 @@ class random_access_handle_service
   }
 
   /// Cancel all asynchronous operations associated with the handle.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Write the given data at the specified offset.
@@ -164,11 +156,11 @@ class random_access_handle_service
       uint64_t offset, const ConstBufferSequence& buffers,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    asio::detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    asio::async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_write_some_at(impl, offset, buffers, init.handler);
+    service_impl_.async_write_some_at(impl,
+        offset, buffers, init.completion_handler);
 
     return init.result.get();
   }
@@ -189,20 +181,20 @@ class random_access_handle_service
       uint64_t offset, const MutableBufferSequence& buffers,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    asio::detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    asio::async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_read_some_at(impl, offset, buffers, init.handler);
+    service_impl_.async_read_some_at(impl,
+        offset, buffers, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -217,4 +209,6 @@ class random_access_handle_service
 #endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_SERVICE_HPP
diff --git a/extern/include/asio/windows/stream_handle.hpp b/extern/include/asio/windows/stream_handle.hpp
index b35dd754..8f0a21b1 100644
--- a/extern/include/asio/windows/stream_handle.hpp
+++ b/extern/include/asio/windows/stream_handle.hpp
@@ -2,7 +2,7 @@
 // windows/stream_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,21 +16,346 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/windows/overlapped_handle.hpp"
 
 #if defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
-#include "asio/windows/basic_stream_handle.hpp"
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+# include "asio/windows/basic_stream_handle.hpp"
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
+#include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace windows {
 
-/// Typedef for the typical usage of a stream-oriented handle.
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+// Typedef for the typical usage of a stream-oriented handle.
 typedef basic_stream_handle<> stream_handle;
+#else // defined(ASIO_ENABLE_OLD_SERVICES)
+/// Provides stream-oriented handle functionality.
+/**
+ * The windows::stream_handle class provides asynchronous and blocking
+ * stream-oriented handle functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
+ */
+class stream_handle
+  : public overlapped_handle
+{
+public:
+  /// Construct a stream_handle without opening it.
+  /**
+   * This constructor creates a stream handle without opening it. The handle
+   * needs to be opened and then connected or accepted before data can be sent
+   * or received on it.
+   *
+   * @param io_context The io_context object that the stream handle will use to
+   * dispatch handlers for any asynchronous operations performed on the handle.
+   */
+  explicit stream_handle(asio::io_context& io_context)
+    : overlapped_handle(io_context)
+  {
+  }
+
+  /// Construct a stream_handle on an existing native handle.
+  /**
+   * This constructor creates a stream handle object to hold an existing native
+   * handle.
+   *
+   * @param io_context The io_context object that the stream handle will use to
+   * dispatch handlers for any asynchronous operations performed on the handle.
+   *
+   * @param handle The new underlying handle implementation.
+   *
+   * @throws asio::system_error Thrown on failure.
+   */
+  stream_handle(asio::io_context& io_context,
+      const native_handle_type& handle)
+    : overlapped_handle(io_context, handle)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a stream_handle from another.
+  /**
+   * This constructor moves a stream handle from one object to another.
+   *
+   * @param other The other 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 stream_handle(io_context&) constructor.
+   */
+  stream_handle(stream_handle&& other)
+    : overlapped_handle(std::move(other))
+  {
+  }
+
+  /// Move-assign a stream_handle from another.
+  /**
+   * This assignment operator moves a stream handle from one object to
+   * another.
+   *
+   * @param other The other 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 stream_handle(io_context&) constructor.
+   */
+  stream_handle& operator=(stream_handle&& other)
+  {
+    overlapped_handle::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(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
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The write_some 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.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.write_some(asio::buffer(data, size));
+   * @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.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+    asio::detail::throw_error(ec, "write_some");
+    return s;
+  }
+
+  /// Write some data to the handle.
+  /**
+   * This function is used to write data to the stream handle. The function call
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some 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 write_some(const ConstBufferSequence& buffers,
+      asio::error_code& ec)
+  {
+    return this->get_service().write_some(
+        this->get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the stream handle.
+   * The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   * 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 handler The handler to be called when the write operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes written.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write function if you need to ensure that all
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_write_some(asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename ConstBufferSequence, typename WriteHandler>
+  ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (asio::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      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.
+    ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+    asio::async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_write_some(
+        this->get_implementation(), buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+
+  /// Read some data from the handle.
+  /**
+   * This function is used to read data from the stream handle. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws asio::system_error Thrown on failure. An error code of
+   * asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The read_some operation may not read 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 read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.read_some(asio::buffer(data, size));
+   * @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.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers)
+  {
+    asio::error_code ec;
+    std::size_t s = this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+    asio::detail::throw_error(ec, "read_some");
+    return s;
+  }
+
+  /// Read some data from the handle.
+  /**
+   * This function is used to read data from the stream handle. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read 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 read_some(const MutableBufferSequence& buffers,
+      asio::error_code& ec)
+  {
+    return this->get_service().read_some(
+        this->get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the stream handle.
+   * The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * 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 handler The handler to be called when the read operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const asio::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred           // Number of bytes read.
+   * ); @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
+   * asio::io_context::post().
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read function if you need to ensure that the
+   * requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_read_some(asio::buffer(data, size), handler);
+   * @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.
+   */
+  template <typename MutableBufferSequence, typename ReadHandler>
+  ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (asio::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      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.
+    ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+    asio::async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
+
+    this->get_service().async_read_some(
+        this->get_implementation(), buffers, init.completion_handler);
+
+    return init.result.get();
+  }
+};
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
 
 } // namespace windows
 } // namespace asio
 
+#include "asio/detail/pop_options.hpp"
+
 #endif // defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
diff --git a/extern/include/asio/windows/stream_handle_service.hpp b/extern/include/asio/windows/stream_handle_service.hpp
index 32ec49f5..1c665d5e 100644
--- a/extern/include/asio/windows/stream_handle_service.hpp
+++ b/extern/include/asio/windows/stream_handle_service.hpp
@@ -2,7 +2,7 @@
 // windows/stream_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
+#if defined(ASIO_ENABLE_OLD_SERVICES)
+
 #if defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
@@ -24,7 +26,7 @@
 #include "asio/async_result.hpp"
 #include "asio/detail/win_iocp_handle_service.hpp"
 #include "asio/error.hpp"
-#include "asio/io_service.hpp"
+#include "asio/io_context.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -34,7 +36,7 @@ namespace windows {
 /// Default service implementation for a stream handle.
 class stream_handle_service
 #if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
+  : public asio::io_context::service
 #else
   : public asio::detail::service_base<stream_handle_service>
 #endif
@@ -42,7 +44,7 @@ class stream_handle_service
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
-  static asio::io_service::id id;
+  static asio::io_context::id id;
 #endif
 
 private:
@@ -57,13 +59,6 @@ class stream_handle_service
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native handle type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_handle_type;
@@ -71,10 +66,10 @@ class stream_handle_service
   typedef service_impl_type::native_handle_type native_handle_type;
 #endif
 
-  /// Construct a new stream handle service for the specified io_service.
-  explicit stream_handle_service(asio::io_service& io_service)
-    : asio::detail::service_base<stream_handle_service>(io_service),
-      service_impl_(io_service)
+  /// Construct a new stream handle service for the specified io_context.
+  explicit stream_handle_service(asio::io_context& io_context)
+    : asio::detail::service_base<stream_handle_service>(io_context),
+      service_impl_(io_context)
   {
   }
 
@@ -108,10 +103,11 @@ class stream_handle_service
   }
 
   /// Assign an existing native handle to a stream handle.
-  asio::error_code assign(implementation_type& impl,
+  ASIO_SYNC_OP_VOID assign(implementation_type& impl,
       const native_handle_type& handle, asio::error_code& ec)
   {
-    return service_impl_.assign(impl, handle, ec);
+    service_impl_.assign(impl, handle, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Determine whether the handle is open.
@@ -121,16 +117,11 @@ class stream_handle_service
   }
 
   /// Close a stream handle implementation.
-  asio::error_code close(implementation_type& impl,
+  ASIO_SYNC_OP_VOID close(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.close(impl, ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native handle implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
+    service_impl_.close(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Get the native handle implementation.
@@ -140,10 +131,11 @@ class stream_handle_service
   }
 
   /// Cancel all asynchronous operations associated with the handle.
-  asio::error_code cancel(implementation_type& impl,
+  ASIO_SYNC_OP_VOID cancel(implementation_type& impl,
       asio::error_code& ec)
   {
-    return service_impl_.cancel(impl, ec);
+    service_impl_.cancel(impl, ec);
+    ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Write the given data to the stream.
@@ -162,11 +154,10 @@ class stream_handle_service
       const ConstBufferSequence& buffers,
       ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    asio::detail::async_result_init<
-      WriteHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(WriteHandler)(handler));
+    asio::async_completion<WriteHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_write_some(impl, buffers, init.handler);
+    service_impl_.async_write_some(impl, buffers, init.completion_handler);
 
     return init.result.get();
   }
@@ -187,20 +178,19 @@ class stream_handle_service
       const MutableBufferSequence& buffers,
       ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    asio::detail::async_result_init<
-      ReadHandler, void (asio::error_code, std::size_t)> init(
-        ASIO_MOVE_CAST(ReadHandler)(handler));
+    asio::async_completion<ReadHandler,
+      void (asio::error_code, std::size_t)> init(handler);
 
-    service_impl_.async_read_some(impl, buffers, init.handler);
+    service_impl_.async_read_some(impl, buffers, init.completion_handler);
 
     return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
+  void shutdown()
   {
-    service_impl_.shutdown_service();
+    service_impl_.shutdown();
   }
 
   // The platform-specific implementation.
@@ -215,4 +205,6 @@ class stream_handle_service
 #endif // defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
+#endif // defined(ASIO_ENABLE_OLD_SERVICES)
+
 #endif // ASIO_WINDOWS_STREAM_HANDLE_SERVICE_HPP
diff --git a/extern/include/asio/write.hpp b/extern/include/asio/write.hpp
index 15445e47..517a8420 100644
--- a/extern/include/asio/write.hpp
+++ b/extern/include/asio/write.hpp
@@ -2,7 +2,7 @@
 // write.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,9 +18,13 @@
 #include "asio/detail/config.hpp"
 #include <cstddef>
 #include "asio/async_result.hpp"
-#include "asio/basic_streambuf_fwd.hpp"
+#include "asio/buffer.hpp"
 #include "asio/error.hpp"
 
+#if !defined(ASIO_NO_EXTENSIONS)
+# include "asio/basic_streambuf_fwd.hpp"
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -69,7 +73,10 @@ namespace asio {
  *     asio::transfer_all()); @endcode
  */
 template <typename SyncWriteStream, typename ConstBufferSequence>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
+std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type* = 0);
 
 /// Write all of the supplied data to a stream before returning.
 /**
@@ -109,7 +116,10 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
  */
 template <typename SyncWriteStream, typename ConstBufferSequence>
 std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    asio::error_code& ec);
+    asio::error_code& ec,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type* = 0);
 
 /// Write a certain amount of data to a stream before returning.
 /**
@@ -160,7 +170,10 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition);
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type* = 0);
 
 /// Write a certain amount of data to a stream before returning.
 /**
@@ -204,8 +217,172 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec);
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type* = 0);
+
+/// 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 dynamic buffer sequence 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 buffers The dynamic buffer sequence from which data will be written.
+ * Successfully written data is automatically consumed from the buffers.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws asio::system_error Thrown on failure.
+ *
+ * @note This overload is equivalent to calling:
+ * @code asio::write(
+ *     s, buffers,
+ *     asio::transfer_all()); @endcode
+ */
+template <typename SyncWriteStream, typename DynamicBuffer>
+std::size_t write(SyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+/// 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 dynamic buffer sequence 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 buffers The dynamic buffer sequence from which data will be written.
+ * Successfully written data is automatically consumed from the buffers.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @note This overload is equivalent to calling:
+ * @code asio::write(
+ *     s, buffers,
+ *     asio::transfer_all(), ec); @endcode
+ */
+template <typename SyncWriteStream, typename DynamicBuffer>
+std::size_t write(SyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+/// 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.
+ * The call will block until one of the following conditions is true:
+ *
+ * @li All of the data in the supplied dynamic buffer sequence has been written.
+ *
+ * @li The completion_condition function object returns 0.
+ *
+ * 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 The dynamic buffer sequence from which data will be written.
+ * Successfully written data is automatically consumed from the buffers.
+ *
+ * @param completion_condition The function object to be called to determine
+ * whether the write operation is complete. The signature of the function object
+ * must be:
+ * @code std::size_t completion_condition(
+ *   // Result of latest write_some operation.
+ *   const asio::error_code& error,
+ *
+ *   // Number of bytes transferred so far.
+ *   std::size_t bytes_transferred
+ * ); @endcode
+ * A return value of 0 indicates that the write operation is complete. A
+ * non-zero return value indicates the maximum number of bytes to be written on
+ * the next call to the stream's write_some function.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws asio::system_error Thrown on failure.
+ */
+template <typename SyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition>
+std::size_t write(SyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+/// 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.
+ * The call will block until one of the following conditions is true:
+ *
+ * @li All of the data in the supplied dynamic buffer sequence has been written.
+ *
+ * @li The completion_condition function object returns 0.
+ *
+ * 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 The dynamic buffer sequence from which data will be written.
+ * Successfully written data is automatically consumed from the buffers.
+ *
+ * @param completion_condition The function object to be called to determine
+ * whether the write operation is complete. The signature of the function object
+ * must be:
+ * @code std::size_t completion_condition(
+ *   // Result of latest write_some operation.
+ *   const asio::error_code& error,
+ *
+ *   // Number of bytes transferred so far.
+ *   std::size_t bytes_transferred
+ * ); @endcode
+ * A return value of 0 indicates that the write operation is complete. A
+ * non-zero return value indicates the maximum number of bytes to be written on
+ * the next call to the stream's write_some function.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ *
+ * @returns The number of bytes written. If an error occurs, returns the total
+ * number of bytes successfully transferred prior to the error.
+ */
+template <typename SyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition>
+std::size_t write(SyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition, asio::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Write all of the supplied data to a stream before returning.
@@ -349,6 +526,7 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, asio::error_code& ec);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 /**
@@ -400,7 +578,7 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
@@ -416,7 +594,10 @@ template <typename AsyncWriteStream, typename ConstBufferSequence,
 ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (asio::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    ASIO_MOVE_ARG(WriteHandler) handler);
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type* = 0);
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
@@ -473,7 +654,7 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
@@ -491,8 +672,135 @@ ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (asio::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(WriteHandler) handler);
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type* = 0);
+
+/// Start an asynchronous operation to write all of the supplied data to a
+/// stream.
+/**
+ * This function is used to asynchronously write a certain number of bytes of
+ * data to a stream. The function call always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions
+ * is true:
+ *
+ * @li All of the data in the supplied dynamic buffer sequence has been written.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * async_write_some function, and is known as a <em>composed operation</em>. The
+ * program must ensure that the stream performs no other write operations (such
+ * as async_write, the stream's async_write_some function, or any other composed
+ * operations that perform writes) until this operation completes.
+ *
+ * @param s The stream to which the data is to be written. The type must support
+ * the AsyncWriteStream concept.
+ *
+ * @param buffers The dynamic buffer sequence from which data will be written.
+ * 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. Successfully written
+ * data is automatically consumed from the buffers.
+ *
+ * @param handler The handler to be called when the write operation completes.
+ * Copies will be made of the handler as required. The function signature of the
+ * handler must be:
+ * @code void handler(
+ *   const asio::error_code& error, // Result of operation.
+ *
+ *   std::size_t bytes_transferred           // Number of bytes written from the
+ *                                           // buffers. If an error occurred,
+ *                                           // this will be less than the sum
+ *                                           // of the buffer sizes.
+ * ); @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
+ * asio::io_context::post().
+ */
+template <typename AsyncWriteStream,
+    typename DynamicBuffer, typename WriteHandler>
+ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (asio::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
+
+/// Start an asynchronous operation to write a certain amount of data to a
+/// stream.
+/**
+ * This function is used to asynchronously write a certain number of bytes of
+ * data to a stream. The function call always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions
+ * is true:
+ *
+ * @li All of the data in the supplied dynamic buffer sequence has been written.
+ *
+ * @li The completion_condition function object returns 0.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * async_write_some function, and is known as a <em>composed operation</em>. The
+ * program must ensure that the stream performs no other write operations (such
+ * as async_write, the stream's async_write_some function, or any other composed
+ * operations that perform writes) until this operation completes.
+ *
+ * @param s The stream to which the data is to be written. The type must support
+ * the AsyncWriteStream concept.
+ *
+ * @param buffers The dynamic buffer sequence from which data will be written.
+ * 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. Successfully written
+ * data is automatically consumed from the buffers.
+ *
+ * @param completion_condition The function object to be called to determine
+ * whether the write operation is complete. The signature of the function object
+ * must be:
+ * @code std::size_t completion_condition(
+ *   // Result of latest async_write_some operation.
+ *   const asio::error_code& error,
+ *
+ *   // Number of bytes transferred so far.
+ *   std::size_t bytes_transferred
+ * ); @endcode
+ * A return value of 0 indicates that the write operation is complete. A
+ * non-zero return value indicates the maximum number of bytes to be written on
+ * the next call to the stream's async_write_some function.
+ *
+ * @param handler The handler to be called when the write operation completes.
+ * Copies will be made of the handler as required. The function signature of the
+ * handler must be:
+ * @code void handler(
+ *   const asio::error_code& error, // Result of operation.
+ *
+ *   std::size_t bytes_transferred           // Number of bytes written from the
+ *                                           // buffers. If an error occurred,
+ *                                           // this will be less than the sum
+ *                                           // of the buffer sizes.
+ * ); @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
+ * asio::io_context::post().
+ */
+template <typename AsyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition, typename WriteHandler>
+ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (asio::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
+    ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition,
+    ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
+    >::type* = 0);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to write all of the supplied data to a
@@ -534,7 +842,7 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  */
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
 ASIO_INITFN_RESULT_TYPE(WriteHandler,
@@ -595,7 +903,7 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  */
 template <typename AsyncWriteStream, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
@@ -606,6 +914,7 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
     ASIO_MOVE_ARG(WriteHandler) handler);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 
diff --git a/extern/include/asio/write_at.hpp b/extern/include/asio/write_at.hpp
index 45edd08d..5018d210 100644
--- a/extern/include/asio/write_at.hpp
+++ b/extern/include/asio/write_at.hpp
@@ -2,7 +2,7 @@
 // write_at.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,10 +18,13 @@
 #include "asio/detail/config.hpp"
 #include <cstddef>
 #include "asio/async_result.hpp"
-#include "asio/basic_streambuf_fwd.hpp"
 #include "asio/detail/cstdint.hpp"
 #include "asio/error.hpp"
 
+#if !defined(ASIO_NO_EXTENSIONS)
+# include "asio/basic_streambuf_fwd.hpp"
+#endif // !defined(ASIO_NO_EXTENSIONS)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -224,6 +227,7 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition, asio::error_code& ec);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Write all of the supplied data at the specified offset before returning.
@@ -382,6 +386,7 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
     asio::error_code& ec);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 /**
@@ -437,7 +442,7 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
@@ -515,7 +520,7 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
@@ -536,6 +541,7 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
     CompletionCondition completion_condition,
     ASIO_MOVE_ARG(WriteHandler) handler);
 
+#if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to write all of the supplied data at the
@@ -581,7 +587,7 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  */
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename WriteHandler>
@@ -647,7 +653,7 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
  * 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
- * asio::io_service::post().
+ * asio::io_context::post().
  */
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
@@ -658,6 +664,7 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
     ASIO_MOVE_ARG(WriteHandler) handler);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
+#endif // !defined(ASIO_NO_EXTENSIONS)
 
 /*@}*/
 
diff --git a/extern/include/asio/yield.hpp b/extern/include/asio/yield.hpp
index 6cf5d6ba..b527ac9b 100644
--- a/extern/include/asio/yield.hpp
+++ b/extern/include/asio/yield.hpp
@@ -2,7 +2,7 @@
 // yield.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/src/network/connection.cpp b/src/network/connection.cpp
index ac2defb8..66d0a356 100644
--- a/src/network/connection.cpp
+++ b/src/network/connection.cpp
@@ -61,7 +61,6 @@ ssr::Connection::create(asio::io_service &io_service
     , Publisher& controller, char end_of_message_character)
 {
   VERBOSE2("New network connection ...");
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
   return pointer(new Connection(io_service, controller
       , end_of_message_character));
 }
diff --git a/src/network/server.cpp b/src/network/server.cpp
index b5d3c51f..39343bdc 100644
--- a/src/network/server.cpp
+++ b/src/network/server.cpp
@@ -28,8 +28,13 @@
 /// Server class (implementation).
 
 #include <functional>
+#include <thread>
+#include <mutex>
 #include "server.h"
 
+std::mutex accept_mutex;  // protects ssr::Server::start_accept()
+
+
 ssr::Server::Server(Publisher& controller, int port
     , char end_of_message_character)
   : _controller(controller)
@@ -48,13 +53,17 @@ ssr::Server::~Server()
 void
 ssr::Server::start_accept()
 {
+  // lock accept_mutex
+  std::lock_guard<std::mutex> lock(accept_mutex);
+
   Connection::pointer new_connection = Connection::create(_io_service
       , _controller, _end_of_message_character);
 
   _acceptor.async_accept(new_connection->socket()
       , std::bind(&Server::handle_accept, this, new_connection
       , std::placeholders::_1));
-  VERBOSE2("Network connection accepted.");
+
+  // accept_mutex released when lock goes out of scope
 }
 
 void
@@ -64,6 +73,8 @@ ssr::Server::handle_accept(Connection::pointer new_connection
   if (!error)
   {
     new_connection->start();
+    VERBOSE2("Network connection accepted.");
+
     start_accept();
   }
 }