diff --git a/asio/include/Makefile.am b/asio/include/Makefile.am
index 4b81b3d..37679d8 100644
--- a/asio/include/Makefile.am
+++ b/asio/include/Makefile.am
@@ -58,6 +58,7 @@
 	asio/detail/handler_alloc_helpers.hpp \
 	asio/detail/handler_invoke_helpers.hpp \
 	asio/detail/handler_tracking.hpp \
+	asio/detail/handler_traits.hpp \
 	asio/detail/handler_type_requirements.hpp \
 	asio/detail/hash_map.hpp \
 	asio/detail/impl/descriptor_ops.ipp \
@@ -219,6 +220,7 @@
 	asio/error.hpp \
 	asio/handler_alloc_hook.hpp \
 	asio/handler_invoke_hook.hpp \
+	asio/handler_traits.hpp \
 	asio.hpp \
 	asio/impl/connect.hpp \
 	asio/impl/error_code.ipp \
diff --git a/asio/include/asio.hpp b/asio/include/asio.hpp
index 398fbeb..4182bad 100644
--- a/asio/include/asio.hpp
+++ b/asio/include/asio.hpp
@@ -44,6 +44,7 @@
 #include "asio/error_code.hpp"
 #include "asio/handler_alloc_hook.hpp"
 #include "asio/handler_invoke_hook.hpp"
+#include "asio/handler_traits.hpp"
 #include "asio/io_service.hpp"
 #include "asio/ip/address.hpp"
 #include "asio/ip/address_v4.hpp"
diff --git a/asio/include/asio/detail/completion_handler.hpp b/asio/include/asio/detail/completion_handler.hpp
index 628b712..2a2aa79 100644
--- a/asio/include/asio/detail/completion_handler.hpp
+++ b/asio/include/asio/detail/completion_handler.hpp
@@ -17,9 +17,8 @@
 
 #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/operation.hpp"
+#include "asio/handler_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -62,7 +61,8 @@
     {
       asio::detail::fenced_block b;
       ASIO_HANDLER_INVOCATION_BEGIN(());
-      asio_handler_invoke_helpers::invoke(handler, handler);
+      ptr::traits_type::get_invoker(handler).invoke(
+          ASIO_MOVE_CAST(Handler)(handler));
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/asio/include/asio/detail/deadline_timer_service.hpp b/asio/include/asio/detail/deadline_timer_service.hpp
index 6eb0434..3cca342 100644
--- a/asio/include/asio/detail/deadline_timer_service.hpp
+++ b/asio/include/asio/detail/deadline_timer_service.hpp
@@ -182,8 +182,7 @@
     // Allocate and construct an operation to wrap the handler.
     typedef wait_handler<Handler> op;
     typename op::ptr p = { boost::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;
diff --git a/asio/include/asio/detail/handler_alloc_helpers.hpp b/asio/include/asio/detail/handler_alloc_helpers.hpp
index 9ae80de..0f70626 100644
--- a/asio/include/asio/detail/handler_alloc_helpers.hpp
+++ b/asio/include/asio/detail/handler_alloc_helpers.hpp
@@ -17,6 +17,7 @@
 
 #include "asio/detail/config.hpp"
 #include <boost/detail/workaround.hpp>
+#include <boost/limits.hpp>
 #include <boost/utility/addressof.hpp>
 #include "asio/detail/noncopyable.hpp"
 #include "asio/handler_alloc_hook.hpp"
@@ -54,31 +55,131 @@
 
 } // namespace asio_handler_alloc_helpers
 
-#define ASIO_DEFINE_HANDLER_PTR(op) \
-  struct ptr \
-  { \
-    Handler* h; \
-    void* v; \
-    op* p; \
-    ~ptr() \
-    { \
-      reset(); \
-    } \
-    void reset() \
-    { \
-      if (p) \
-      { \
-        p->~op(); \
-        p = 0; \
-      } \
-      if (v) \
-      { \
-        asio_handler_alloc_helpers::deallocate(v, sizeof(op), *h); \
-        v = 0; \
-      } \
-    } \
-  } \
-  /**/
+namespace asio {
+namespace detail {
+
+// The default allocator simply forwards to the old-style allocation hook.
+template <typename T, typename Context>
+class default_handler_allocator
+{
+public:
+  typedef T value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  template <typename U>
+  struct rebind
+  {
+    typedef default_handler_allocator<U, Context> other;
+  };
+
+  explicit default_handler_allocator(Context* context)
+    : context_(context)
+  {
+  }
+
+  template <typename U>
+  default_handler_allocator(const default_handler_allocator<U, Context>& other)
+    : context_(other.context_)
+  {
+  }
+
+  static pointer address(reference r)
+  {
+    return &r;
+  }
+
+  static const_pointer address(const_reference r)
+  {
+    return &r;
+  }
+
+  static size_type max_size()
+  {
+    return (std::numeric_limits<size_type>::max)();
+  }
+
+  static void construct(const pointer p, const value_type& v)
+  {
+    new (p) T(v);
+  }
+
+  static void destroy(const pointer p)
+  {
+    p->~T();
+  }
+
+  bool operator==(const default_handler_allocator& other) const
+  {
+    return context_ == other.context_;
+  }
+
+  bool operator!=(const default_handler_allocator& other) const
+  {
+    return context_ != other.context_;
+  }
+
+  pointer allocate(size_type n, const void* = 0)
+  {
+    return static_cast<pointer>(
+        asio_handler_alloc_helpers::allocate(n * sizeof(T), *context_));
+  }
+
+  void deallocate(pointer p, size_type n)
+  {
+    return asio_handler_alloc_helpers::deallocate(p, n * sizeof(T), *context_);
+  }
+
+//private:
+  Context* context_;
+};
+
+// The default allocator specialised for void.
+template <typename Context>
+class default_handler_allocator<void, Context>
+{
+public:
+  typedef void value_type;
+  typedef void* pointer;
+  typedef const void* const_pointer;
+
+  template <typename U>
+  struct rebind
+  {
+    typedef default_handler_allocator<U, Context> other;
+  };
+
+  explicit default_handler_allocator(Context* context)
+    : context_(context)
+  {
+  }
+
+  template <typename U>
+  default_handler_allocator(const default_handler_allocator<U, Context>& other)
+    : context_(other.context_)
+  {
+  }
+
+  bool operator==(const default_handler_allocator& other) const
+  {
+    return context_ == other.context_;
+  }
+
+  bool operator!=(const default_handler_allocator& other) const
+  {
+    return context_ != other.context_;
+  }
+
+//private:
+  Context* context_;
+};
+
+} // namespace detail
+} // namespace asio
 
 #include "asio/detail/pop_options.hpp"
 
diff --git a/asio/include/asio/detail/handler_invoke_helpers.hpp b/asio/include/asio/detail/handler_invoke_helpers.hpp
index 5b122d9..2b30079 100644
--- a/asio/include/asio/detail/handler_invoke_helpers.hpp
+++ b/asio/include/asio/detail/handler_invoke_helpers.hpp
@@ -42,6 +42,32 @@
 
 } // namespace asio_handler_invoke_helpers
 
+namespace asio {
+namespace detail {
+
+// The default invoker simply forwards to the old-style invocation hook.
+template <typename Context>
+class default_handler_invoker
+{
+public:
+  explicit default_handler_invoker(Context* context)
+    : context_(context)
+  {
+  }
+
+  template <typename Function>
+  void invoke(Function function)
+  {
+    asio_handler_invoke_helpers::invoke(function, *context_);
+  }
+
+private:
+  Context* context_;
+};
+
+} // namespace detail
+} // namespace asio
+
 #include "asio/detail/pop_options.hpp"
 
 #endif // ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
diff --git a/asio/include/asio/detail/handler_traits.hpp b/asio/include/asio/detail/handler_traits.hpp
new file mode 100644
index 0000000..778664c
--- /dev/null
+++ b/asio/include/asio/detail/handler_traits.hpp
@@ -0,0 +1,160 @@
+//
+// detail/handler_traits.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_HANDLER_TRAITS_HPP
+#define ASIO_DETAIL_HANDLER_TRAITS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <boost/utility/addressof.hpp>
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+// Type trait for determining whether a handler has an invoker_type typedef.
+
+char (&invoker_type_test(...))[2];
+
+template <typename T> char invoker_type_test(
+    T*, typename T::invoker_type* = 0);
+
+template <typename T>
+struct has_invoker_type
+{
+  enum { value = (sizeof((invoker_type_test)(static_cast<T*>(0))) == 1) };
+};
+
+// Type trait for determining whether a handler has an allocator_type typedef.
+
+char (&allocator_type_test(...))[2];
+
+template <typename T> char allocator_type_test(
+    T*, typename T::allocator_type* = 0);
+
+template <typename T>
+struct has_allocator_type
+{
+  enum { value = (sizeof((allocator_type_test)(static_cast<T*>(0))) == 1) };
+};
+
+// Traits base class for selectively forwarding the invoker typedef and
+// accessor function to the handler class.
+
+template <typename Handler, bool HasInvoker = has_invoker_type<Handler>::value>
+struct handler_traits_invoker;
+
+template <typename Handler>
+struct handler_traits_invoker<Handler, true>
+{
+  typedef typename Handler::invoker_type invoker_type;
+
+  static invoker_type get_invoker(Handler& handler)
+  {
+    return handler.get_invoker();
+  }
+};
+
+template <typename Handler>
+struct handler_traits_invoker<Handler, false>
+{
+  typedef default_handler_invoker<Handler> invoker_type;
+
+  static invoker_type get_invoker(Handler& handler)
+  {
+    return invoker_type(boost::addressof(handler));
+  }
+};
+
+// Traits base class for selectively forwarding the allocator typedef and
+// accessor function to the handler class.
+
+template <typename Handler, bool HasAllocator = has_allocator_type<Handler>::value>
+struct handler_traits_allocator;
+
+template <typename Handler>
+struct handler_traits_allocator<Handler, true>
+{
+  typedef typename Handler::allocator_type allocator_type;
+
+  static allocator_type get_allocator(Handler& handler)
+  {
+    return handler.get_allocator();
+  }
+};
+
+template <typename Handler>
+struct handler_traits_allocator<Handler, false>
+{
+  typedef default_handler_allocator<void, Handler> allocator_type;
+
+  static allocator_type get_allocator(Handler& handler)
+  {
+    return allocator_type(boost::addressof(handler));
+  }
+};
+
+// The default handler traits.
+
+template <typename Handler>
+struct handler_traits :
+  handler_traits_invoker<Handler>,
+  handler_traits_allocator<Handler>
+{
+};
+
+} // namespace detail
+} // namespace asio
+
+#define ASIO_DEFINE_HANDLER_PTR(op) \
+  struct ptr \
+  { \
+    typedef asio::handler_traits<Handler> traits_type; \
+    typedef typename traits_type::allocator_type any_allocator_type; \
+    typedef typename any_allocator_type::template rebind< \
+        op>::other allocator_type; \
+    Handler* h; \
+    void* v; \
+    op* p; \
+    static op* allocate(Handler& handler) \
+    { \
+      allocator_type allocator = traits_type::get_allocator(handler); \
+      return allocator.allocate(1); \
+    } \
+    ~ptr() \
+    { \
+      reset(); \
+    } \
+    void reset() \
+    { \
+      if (p) \
+      { \
+        p->~op(); \
+        p = 0; \
+      } \
+      if (v) \
+      { \
+        allocator_type allocator = traits_type::get_allocator(*h); \
+        allocator.deallocate(static_cast<op*>(v), 1); \
+        v = 0; \
+      } \
+    } \
+  } \
+  /**/
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_HANDLER_TRAITS_HPP
diff --git a/asio/include/asio/detail/impl/task_io_service.hpp b/asio/include/asio/detail/impl/task_io_service.hpp
index bd0cd25..59bb96e 100644
--- a/asio/include/asio/detail/impl/task_io_service.hpp
+++ b/asio/include/asio/detail/impl/task_io_service.hpp
@@ -18,8 +18,7 @@
 #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/handler_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -39,8 +38,7 @@
     // Allocate and construct an operation to wrap the handler.
     typedef completion_handler<Handler> op;
     typename op::ptr p = { boost::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", this, "dispatch"));
@@ -56,8 +54,7 @@
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
   typename op::ptr p = { boost::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", this, "post"));
diff --git a/asio/include/asio/detail/wait_handler.hpp b/asio/include/asio/detail/wait_handler.hpp
index a5e152c..56eee10 100644
--- a/asio/include/asio/detail/wait_handler.hpp
+++ b/asio/include/asio/detail/wait_handler.hpp
@@ -32,9 +32,9 @@
 public:
   ASIO_DEFINE_HANDLER_PTR(wait_handler);
 
-  wait_handler(Handler h)
+  wait_handler(Handler& h)
     : timer_op(&wait_handler::do_complete),
-      handler_(h)
+      handler_(ASIO_MOVE_CAST(Handler)(h))
   {
   }
 
@@ -53,8 +53,8 @@
     // 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(h->handler_, h->ec_);
+    typedef detail::binder1<Handler, asio::error_code> binder;
+    binder handler(h->handler_, h->ec_);
     p.h = boost::addressof(handler.handler_);
     p.reset();
 
@@ -63,7 +63,8 @@
     {
       asio::detail::fenced_block b;
       ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      ptr::traits_type::get_invoker(handler.handler_).invoke(
+          ASIO_MOVE_CAST(binder)(handler));
       ASIO_HANDLER_INVOCATION_END;
     }
   }
diff --git a/asio/include/asio/handler_traits.hpp b/asio/include/asio/handler_traits.hpp
new file mode 100644
index 0000000..3b81ef6
--- /dev/null
+++ b/asio/include/asio/handler_traits.hpp
@@ -0,0 +1,35 @@
+//
+// handler_traits.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_HANDLER_TRAITS_HPP
+#define ASIO_HANDLER_TRAITS_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/handler_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+template <typename Handler>
+struct handler_traits
+  : asio::detail::handler_traits<Handler>
+{
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_HANDLER_TRAITS_HPP