diff --git a/asio/include/asio.hpp b/asio/include/asio.hpp
index ae15132..cb46bde 100644
--- a/asio/include/asio.hpp
+++ b/asio/include/asio.hpp
@@ -108,6 +108,7 @@
 #include "asio/read.hpp"
 #include "asio/read_at.hpp"
 #include "asio/read_until.hpp"
+#include "asio/redirect_error.hpp"
 #include "asio/seq_packet_socket_service.hpp"
 #include "asio/serial_port.hpp"
 #include "asio/serial_port_base.hpp"
diff --git a/asio/include/asio/impl/await.hpp b/asio/include/asio/impl/await.hpp
index 3630875..a253a1e 100644
--- a/asio/include/asio/impl/await.hpp
+++ b/asio/include/asio/impl/await.hpp
@@ -396,7 +396,7 @@
   void operator()(std::exception_ptr ex)
   {
     awaiter_ptr ptr(std::move(awaiter_));
-    if (ec)
+    if (ex)
       awaitee_->set_exception(ex);
     else
       awaitee_->return_void();
@@ -415,10 +415,7 @@
   void operator()(T t)
   {
     awaiter_ptr ptr(std::move(awaiter_));
-    if (ec)
-      awaitee_->set_exception(ex);
-    else
-      awaitee_->return_value(std::forward<T>(t));
+    awaitee_->return_value(std::forward<T>(t));
     awaitee_->wake_caller();
     ptr->rethrow_exception();
   }
@@ -453,7 +450,7 @@
   void operator()(std::exception_ptr ex, T t)
   {
     awaiter_ptr ptr(std::move(awaiter_));
-    if (ec)
+    if (ex)
       awaitee_->set_exception(ex);
     else
       awaitee_->return_value(std::forward<T>(t));
diff --git a/asio/include/asio/impl/redirect_error.hpp b/asio/include/asio/impl/redirect_error.hpp
new file mode 100644
index 0000000..45a3c4f
--- /dev/null
+++ b/asio/include/asio/impl/redirect_error.hpp
@@ -0,0 +1,256 @@
+//
+// impl/redirect_error.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_REDIRECT_ERROR_HPP
+#define ASIO_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_invoke_helpers.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 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_))
+    {
+    }
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename... Args>
+    void operator()(ASIO_MOVE_ARG(Args)... args)
+    {
+      handler_(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)
+
+    void operator()()
+    {
+      handler_();
+    }
+
+    void operator()(const asio::error_code& ec)
+    {
+      ec_ = ec;
+      handler_();
+    }
+
+#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \
+    template <ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()(ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      handler_(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(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_);
+  }
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken, typename Signature>
+struct handler_type<redirect_error_t<CompletionToken>, Signature>
+{
+  typedef detail::redirect_error_handler<
+    typename handler_type<CompletionToken,
+      Signature>::type> type;
+};
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename CompletionToken, typename R, typename... Args>
+struct handler_type<redirect_error_t<CompletionToken>,
+    R(asio::error_code, Args...)>
+{
+  typedef detail::redirect_error_handler<
+    typename handler_type<CompletionToken,
+      R(Args...)>::type> type;
+};
+
+template <typename CompletionToken, typename R, typename... Args>
+struct handler_type<redirect_error_t<CompletionToken>,
+    R(const asio::error_code&, Args...)>
+{
+  typedef detail::redirect_error_handler<
+    typename handler_type<CompletionToken,
+      R(Args...)>::type> type;
+};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename CompletionToken, typename R>
+struct handler_type<redirect_error_t<CompletionToken>,
+    R(asio::error_code)>
+{
+  typedef detail::redirect_error_handler<
+    typename handler_type<CompletionToken,
+      R()>::type> type;
+};
+
+template <typename CompletionToken, typename R>
+struct handler_type<redirect_error_t<CompletionToken>,
+    R(const asio::error_code&)>
+{
+  typedef detail::redirect_error_handler<
+    typename handler_type<CompletionToken,
+      R()>::type> type;
+};
+
+#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \
+  template <typename CompletionToken, \
+      typename R, ASIO_VARIADIC_TPARAMS(n)> \
+  struct handler_type<redirect_error_t<CompletionToken>, \
+      R(asio::error_code, ASIO_VARIADIC_TARGS(n))> \
+  { \
+    typedef detail::redirect_error_handler< \
+      typename handler_type<CompletionToken, \
+        R(ASIO_VARIADIC_TARGS(n))>::type> type; \
+  }; \
+  \
+  template <typename CompletionToken, \
+      typename R, ASIO_VARIADIC_TPARAMS(n)> \
+  struct handler_type<redirect_error_t<CompletionToken>, \
+      R(const asio::error_code&, ASIO_VARIADIC_TARGS(n))> \
+  { \
+    typedef detail::redirect_error_handler< \
+      typename handler_type<CompletionToken, \
+        R(ASIO_VARIADIC_TARGS(n))>::type> type; \
+  }; \
+  /**/
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_REDIRECT_ERROR_DEF)
+#undef ASIO_PRIVATE_REDIRECT_ERROR_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Handler>
+struct async_result<detail::redirect_error_handler<Handler> >
+  : async_result<Handler>
+{
+  explicit async_result(detail::redirect_error_handler<Handler>& h)
+    : async_result<Handler>(h.handler_)
+  {
+  }
+};
+
+template <typename Handler, typename Executor>
+struct associated_executor<detail::redirect_error_handler<Handler>, Executor>
+{
+  typedef typename associated_executor<Handler, Executor>::type type;
+
+  static type get(const 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<detail::redirect_error_handler<Handler>, Allocator>
+{
+  typedef typename associated_allocator<Handler, Allocator>::type type;
+
+  static type get(const 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_IMPL_REDIRECT_ERROR_HPP
diff --git a/asio/include/asio/redirect_error.hpp b/asio/include/asio/redirect_error.hpp
new file mode 100644
index 0000000..b2da15c
--- /dev/null
+++ b/asio/include/asio/redirect_error.hpp
@@ -0,0 +1,63 @@
+//
+// redirect_error.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_REDIRECT_ERROR_HPP
+#define ASIO_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/detail/push_options.hpp"
+
+namespace asio {
+
+/// 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, error_code& ec)
+    : token_(ASIO_MOVE_CAST(T)(completion_token)),
+      ec_(ec)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  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, error_code& ec)
+{
+  return redirect_error_t<typename decay<CompletionToken>::type>(
+      ASIO_MOVE_CAST(CompletionToken)(completion_token), ec);
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/redirect_error.hpp"
+
+#endif // ASIO_REDIRECT_ERROR_HPP
diff --git a/asio/src/examples/cpp1z/await/chat_server.cpp b/asio/src/examples/cpp1z/await/chat_server.cpp
new file mode 100644
index 0000000..88afb75
--- /dev/null
+++ b/asio/src/examples/cpp1z/await/chat_server.cpp
@@ -0,0 +1,209 @@
+//
+// chat_server.cpp
+// ~~~~~~~~~~~~~~~
+//
+// 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)
+//
+
+#include <cstdlib>
+#include <deque>
+#include <iostream>
+#include <list>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <asio/await.hpp>
+#include <asio/detached.hpp>
+#include <asio/redirect_error.hpp>
+#include <asio/signal_set.hpp>
+#include <asio/ts/networking.hpp>
+
+using asio::ip::tcp;
+
+//----------------------------------------------------------------------
+
+class chat_participant
+{
+public:
+  virtual ~chat_participant() {}
+  virtual void deliver(const std::string& msg) = 0;
+};
+
+typedef std::shared_ptr<chat_participant> chat_participant_ptr;
+
+//----------------------------------------------------------------------
+
+class chat_room
+{
+public:
+  void join(chat_participant_ptr participant)
+  {
+    participants_.insert(participant);
+    for (auto msg: recent_msgs_)
+      participant->deliver(msg);
+  }
+
+  void leave(chat_participant_ptr participant)
+  {
+    participants_.erase(participant);
+  }
+
+  void deliver(const std::string& msg)
+  {
+    recent_msgs_.push_back(msg);
+    while (recent_msgs_.size() > max_recent_msgs)
+      recent_msgs_.pop_front();
+
+    for (auto participant: participants_)
+      participant->deliver(msg);
+  }
+
+private:
+  std::set<chat_participant_ptr> participants_;
+  enum { max_recent_msgs = 100 };
+  std::deque<std::string> recent_msgs_;
+};
+
+//----------------------------------------------------------------------
+
+class chat_session
+  : public chat_participant,
+    public std::enable_shared_from_this<chat_session>
+{
+public:
+  chat_session(tcp::socket socket, chat_room& room)
+    : socket_(std::move(socket)),
+      timer_(socket_.get_executor().context()),
+      room_(room)
+  {
+    timer_.expires_at(std::chrono::steady_clock::time_point::max());
+  }
+
+  void start()
+  {
+    room_.join(shared_from_this());
+
+    asio::spawn(socket_.get_executor(),
+        &chat_session::reader, shared_from_this(), asio::detached);
+
+    asio::spawn(socket_.get_executor(),
+        &chat_session::writer, shared_from_this(), asio::detached);
+  }
+
+  void deliver(const std::string& msg)
+  {
+    write_msgs_.push_back(msg);
+    timer_.cancel_one();
+  }
+
+private:
+  asio::awaitable<void> reader(asio::await_context ctx)
+  {
+    try
+    {
+      for (std::string read_msg;;)
+      {
+        std::size_t n = co_await asio::async_read_until(socket_,
+            asio::dynamic_buffer(read_msg, 1024), "\n", ctx);
+
+        room_.deliver(read_msg.substr(0, n));
+        read_msg.erase(0, n);
+      }
+    }
+    catch (std::exception&)
+    {
+      stop();
+    }
+  }
+
+  asio::awaitable<void> writer(asio::await_context ctx)
+  {
+    try
+    {
+      while (socket_.is_open())
+      {
+        if (write_msgs_.empty())
+        {
+          asio::error_code ec;
+          co_await timer_.async_wait(asio::redirect_error(ctx, ec));
+        }
+        else
+        {
+          co_await asio::async_write(socket_,
+              asio::buffer(write_msgs_.front()), ctx);
+          write_msgs_.pop_front();
+        }
+      }
+    }
+    catch (std::exception&)
+    {
+      stop();
+    }
+  }
+
+  void stop()
+  {
+    room_.leave(shared_from_this());
+    socket_.close();
+    timer_.cancel();
+  }
+
+  tcp::socket socket_;
+  asio::steady_timer timer_;
+  chat_room& room_;
+  std::deque<std::string> write_msgs_;
+};
+
+//----------------------------------------------------------------------
+
+asio::awaitable<void> listener(tcp::acceptor acceptor, asio::await_context ctx)
+{
+  chat_room room;
+
+  for (;;)
+  {
+    std::make_shared<chat_session>(
+        co_await acceptor.async_accept(ctx),
+        room
+      )->start();
+  }
+}
+
+//----------------------------------------------------------------------
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc < 2)
+    {
+      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
+      return 1;
+    }
+
+    asio::io_context io_context;
+
+    for (int i = 1; i < argc; ++i)
+    {
+      unsigned short port = std::atoi(argv[i]);
+      asio::spawn(io_context, listener,
+          tcp::acceptor(io_context, {tcp::v4(), port}),
+          asio::detached);
+    }
+
+    asio::signal_set signals(io_context, SIGINT, SIGTERM);
+    signals.async_wait([&](auto, auto){ io_context.stop(); });
+
+    io_context.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}