passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/buffered_write_stream.hpp

@@ -2,7 +2,7 @@
 // impl/buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the 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 <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
@@ -53,7 +55,7 @@ namespace detail
     buffered_flush_handler(detail::buffered_stream_storage& storage,
         WriteHandler& handler)
       : storage_(storage),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
@@ -122,7 +124,37 @@ namespace detail
     boost_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()) BOOST_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()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
 
 template <typename Stream>
 template <typename WriteHandler>
@@ -135,14 +167,13 @@ buffered_write_stream<Stream>::async_flush(
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
   async_write(next_layer_, buffer(storage_.data(), storage_.size()),
       detail::buffered_flush_handler<BOOST_ASIO_HANDLER_TYPE(
         WriteHandler, void (boost::system::error_code, std::size_t))>(
-        storage_, init.handler));
+        storage_, init.completion_handler));
 
   return init.result.get();
 }
@@ -152,7 +183,8 @@ template <typename ConstBufferSequence>
 std::size_t buffered_write_stream<Stream>::write_some(
     const ConstBufferSequence& buffers)
 {
-  if (boost::asio::buffer_size(buffers) == 0)
+  using boost::asio::buffer_size;
+  if (buffer_size(buffers) == 0)
     return 0;
 
   if (storage_.size() == storage_.capacity())
@@ -168,7 +200,8 @@ std::size_t buffered_write_stream<Stream>::write_some(
 {
   ec = boost::system::error_code();
 
-  if (boost::asio::buffer_size(buffers) == 0)
+  using boost::asio::buffer_size;
+  if (buffer_size(buffers) == 0)
     return 0;
 
   if (storage_.size() == storage_.capacity() && !flush(ec))
@@ -187,7 +220,7 @@ namespace detail
         const ConstBufferSequence& buffers, WriteHandler& handler)
       : storage_(storage),
         buffers_(buffers),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
@@ -216,9 +249,10 @@ namespace detail
       }
       else
       {
+        using boost::asio::buffer_size;
         std::size_t orig_size = storage_.size();
         std::size_t space_avail = storage_.capacity() - orig_size;
-        std::size_t bytes_avail = boost::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);
@@ -282,6 +316,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()) BOOST_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()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename Stream>
 template <typename ConstBufferSequence, typename WriteHandler>
 BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
@@ -294,25 +366,25 @@ buffered_write_stream<Stream>::async_write_some(
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
-  if (boost::asio::buffer_size(buffers) == 0
+  using boost::asio::buffer_size;
+  if (buffer_size(buffers) == 0
       || storage_.size() < storage_.capacity())
   {
-    next_layer_.async_write_some(boost::asio::const_buffers_1(0, 0),
+    next_layer_.async_write_some(BOOST_ASIO_CONST_BUFFER(0, 0),
         detail::buffered_write_some_handler<
           ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
             WriteHandler, void (boost::system::error_code, std::size_t))>(
-            storage_, buffers, init.handler));
+            storage_, buffers, init.completion_handler));
   }
   else
   {
     this->async_flush(detail::buffered_write_some_handler<
           ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
             WriteHandler, void (boost::system::error_code, std::size_t))>(
-            storage_, buffers, init.handler));
+            storage_, buffers, init.completion_handler));
   }
 
   return init.result.get();
@@ -323,9 +395,10 @@ template <typename ConstBufferSequence>
 std::size_t buffered_write_stream<Stream>::copy(
     const ConstBufferSequence& buffers)
 {
+  using boost::asio::buffer_size;
   std::size_t orig_size = storage_.size();
   std::size_t space_avail = storage_.capacity() - orig_size;
-  std::size_t bytes_avail = boost::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 boost::asio::buffer_copy(

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/connect.hpp

@@ -2,7 +2,7 @@
 // impl/connect.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the 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 <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
-#include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
+#include <boost/asio/post.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -33,16 +36,100 @@ namespace detail
 {
   struct default_connect_condition
   {
-    template <typename Iterator>
-    Iterator operator()(const boost::system::error_code&, Iterator next)
+    template <typename Endpoint>
+    bool operator()(const boost::system::error_code&, const Endpoint&)
     {
-      return next;
+      return true;
     }
   };
+
+  template <typename Protocol, typename Iterator>
+  inline typename Protocol::endpoint deref_connect_result(
+      Iterator iter, boost::system::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 boost::system::error_code*>(0),
+          *static_cast<const Iterator*>(0)))) != 1;
+  };
+
+  template <typename ConnectCondition, typename Iterator>
+  inline Iterator call_connect_condition(ConnectCondition& connect_condition,
+      const boost::system::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 boost::system::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 BOOST_ASIO_SVC_TPARAM, typename EndpointSequence>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  boost::system::error_code ec;
+  typename Protocol::endpoint result = connect(s, endpoints, ec);
+  boost::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 BOOST_ASIO_SVC_TPARAM, typename EndpointSequence>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, boost::system::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(BOOST_ASIO_NO_DEPRECATED)
+template <typename Protocol BOOST_ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s, Iterator begin,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   boost::system::error_code ec;
   Iterator result = connect(s, begin, ec);
@@ -50,15 +137,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, boost::system::error_code& ec)
+template <typename Protocol BOOST_ASIO_SVC_TPARAM, typename Iterator>
+inline Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    Iterator begin, boost::system::error_code& ec,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
 }
+#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+template <typename Protocol BOOST_ASIO_SVC_TPARAM, typename Iterator>
+Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end)
 {
   boost::system::error_code ec;
@@ -67,17 +156,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 BOOST_ASIO_SVC_TPARAM, typename Iterator>
+inline Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, boost::system::error_code& ec)
 {
   return connect(s, begin, end, detail::default_connect_condition(), ec);
 }
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    typename enable_if<is_endpoint_sequence<
+        EndpointSequence>::value>::type*)
+{
+  boost::system::error_code ec;
+  typename Protocol::endpoint result = connect(
+      s, endpoints, connect_condition, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition>
+typename Protocol::endpoint connect(
+    basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    boost::system::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(BOOST_ASIO_NO_DEPRECATED)
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ConnectCondition connect_condition)
+Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    Iterator begin, ConnectCondition connect_condition,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   boost::system::error_code ec;
   Iterator result = connect(s, begin, connect_condition, ec);
@@ -85,18 +205,20 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
   return result;
 }
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+inline Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, ConnectCondition connect_condition,
-    boost::system::error_code& ec)
+    boost::system::error_code& ec,
+    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
 {
   return connect(s, begin, Iterator(), connect_condition, ec);
 }
+#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition)
 {
   boost::system::error_code ec;
@@ -105,9 +227,9 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
   return result;
 }
 
-template <typename Protocol, typename SocketService,
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
     typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
+Iterator connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
     boost::system::error_code& ec)
 {
@@ -115,7 +237,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);
@@ -150,8 +272,7 @@ namespace detail
     void check_condition(const boost::system::error_code& ec,
         Iterator& iter, Iterator& end)
     {
-      if (iter != end)
-        iter = connect_condition_(ec, static_cast<const Iterator&>(iter));
+      iter = detail::call_connect_condition(connect_condition_, ec, iter, end);
     }
 
   private:
@@ -174,26 +295,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 BOOST_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 BOOST_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_(BOOST_ASIO_MOVE_CAST(RangeConnectHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_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_(BOOST_ASIO_MOVE_CAST(RangeConnectHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(boost::system::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,
+                BOOST_ASIO_MOVE_CAST(range_connect_op)(*this));
+            return;
+          }
+
+          if (start)
+          {
+            ec = boost::asio::error::not_found;
+            boost::asio::post(socket_.get_executor(),
+                detail::bind_handler(
+                  BOOST_ASIO_MOVE_CAST(range_connect_op)(*this), ec));
+            return;
+          }
+
+          default:
+
+          if (iter == end)
+            break;
+
+          if (!socket_.is_open())
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+
+          if (!ec)
+            break;
+
+          ++iter;
+          ++index_;
+        }
+
+        handler_(static_cast<const boost::system::error_code&>(ec),
+            static_cast<const typename Protocol::endpoint&>(
+              ec || iter == end ? typename Protocol::endpoint() : *iter));
+      }
+    }
+
+  //private:
+    basic_socket<Protocol BOOST_ASIO_SVC_TARG>& socket_;
+    EndpointSequence endpoints_;
+    std::size_t index_;
+    int start_;
+    RangeConnectHandler handler_;
+  };
+
+  template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+      typename EndpointSequence, typename ConnectCondition,
+      typename RangeConnectHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      range_connect_op<Protocol BOOST_ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+      typename EndpointSequence, typename ConnectCondition,
+      typename RangeConnectHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      range_connect_op<Protocol BOOST_ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+      typename EndpointSequence, typename ConnectCondition,
+      typename RangeConnectHandler>
+  inline bool asio_handler_is_continuation(
+      range_connect_op<Protocol BOOST_ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol
+      BOOST_ASIO_SVC_TPARAM, typename EndpointSequence,
+      typename ConnectCondition, typename RangeConnectHandler>
+  inline void asio_handler_invoke(Function& function,
+      range_connect_op<Protocol BOOST_ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol
+      BOOST_ASIO_SVC_TPARAM, typename EndpointSequence,
+      typename ConnectCondition, typename RangeConnectHandler>
+  inline void asio_handler_invoke(const Function& function,
+      range_connect_op<Protocol BOOST_ASIO_SVC_TARG, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Protocol BOOST_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 BOOST_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_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))
+        handler_(BOOST_ASIO_MOVE_CAST(IteratorConnectHandler)(handler))
     {
     }
 
 #if defined(BOOST_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_),
@@ -203,13 +484,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_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(other.handler_))
+        handler_(BOOST_ASIO_MOVE_CAST(IteratorConnectHandler)(other.handler_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
@@ -227,14 +508,16 @@ namespace detail
           {
             socket_.close(ec);
             socket_.async_connect(*iter_,
-                BOOST_ASIO_MOVE_CAST(connect_op)(*this));
+                BOOST_ASIO_MOVE_CAST(iterator_connect_op)(*this));
             return;
           }
 
           if (start)
           {
             ec = boost::asio::error::not_found;
-            socket_.get_io_service().post(detail::bind_handler(*this, ec));
+            boost::asio::post(socket_.get_executor(),
+                detail::bind_handler(
+                  BOOST_ASIO_MOVE_CAST(iterator_connect_op)(*this), ec));
             return;
           }
 
@@ -261,164 +544,311 @@ namespace detail
     }
 
   //private:
-    basic_socket<Protocol, SocketService>& socket_;
+    basic_socket<Protocol BOOST_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 BOOST_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 BOOST_ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Protocol BOOST_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 BOOST_ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Protocol BOOST_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 BOOST_ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     return boost_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
+      BOOST_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 BOOST_ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename Protocol,
-      typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
+  template <typename Function, typename Protocol
+      BOOST_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 BOOST_ASIO_SVC_TARG, Iterator,
+        ConnectCondition, IteratorConnectHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition,
+    typename RangeConnectHandler, typename Allocator>
+struct associated_allocator<
+    detail::range_connect_op<Protocol BOOST_ASIO_SVC_TARG,
+      EndpointSequence, ConnectCondition, RangeConnectHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<
+      RangeConnectHandler, Allocator>::type type;
+
+  static type get(
+      const detail::range_connect_op<Protocol BOOST_ASIO_SVC_TARG,
+        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<RangeConnectHandler,
+        Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename ConnectCondition,
+    typename RangeConnectHandler, typename Executor>
+struct associated_executor<
+    detail::range_connect_op<Protocol BOOST_ASIO_SVC_TARG,
+      EndpointSequence, ConnectCondition, RangeConnectHandler>,
+    Executor>
+{
+  typedef typename associated_executor<
+      RangeConnectHandler, Executor>::type type;
+
+  static type get(
+      const detail::range_connect_op<Protocol BOOST_ASIO_SVC_TARG,
+        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<RangeConnectHandler,
+        Executor>::get(h.handler_, ex);
+  }
+};
+
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename Iterator, typename ConnectCondition,
+    typename IteratorConnectHandler, typename Allocator>
+struct associated_allocator<
+    detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG, Iterator,
+      ConnectCondition, IteratorConnectHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<
+      IteratorConnectHandler, Allocator>::type type;
+
+  static type get(
+      const detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG,
+        Iterator, ConnectCondition, IteratorConnectHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<IteratorConnectHandler,
+        Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename Iterator, typename ConnectCondition,
+    typename IteratorConnectHandler, typename Executor>
+struct associated_executor<
+    detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG, Iterator,
+      ConnectCondition, IteratorConnectHandler>,
+    Executor>
+{
+  typedef typename associated_executor<
+      IteratorConnectHandler, Executor>::type type;
+
+  static type get(
+      const detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG,
+        Iterator, ConnectCondition, IteratorConnectHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<IteratorConnectHandler,
+        Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename EndpointSequence, typename RangeConnectHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+    void (boost::system::error_code, typename Protocol::endpoint))
+async_connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints,
+    BOOST_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.
+  BOOST_ASIO_RANGE_CONNECT_HANDLER_CHECK(
+      RangeConnectHandler, handler, typename Protocol::endpoint) type_check;
+
+  async_completion<RangeConnectHandler,
+    void (boost::system::error_code, typename Protocol::endpoint)>
+      init(handler);
+
+  detail::range_connect_op<Protocol BOOST_ASIO_SVC_TARG, EndpointSequence,
+    detail::default_connect_condition,
+      BOOST_ASIO_HANDLER_TYPE(RangeConnectHandler,
+        void (boost::system::error_code, typename Protocol::endpoint))>(s,
+          endpoints, detail::default_connect_condition(),
+            init.completion_handler)(boost::system::error_code(), 1);
+
+  return init.result.get();
+}
+
+#if !defined(BOOST_ASIO_NO_DEPRECATED)
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename Iterator, typename IteratorConnectHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (boost::system::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+async_connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    Iterator begin, BOOST_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.
-  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (boost::system::error_code, Iterator)> init(
-      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (boost::system::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG, Iterator,
     detail::default_connect_condition, BOOST_ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
-        begin, Iterator(), detail::default_connect_condition(), init.handler)(
-          boost::system::error_code(), 1);
+      IteratorConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, Iterator(), detail::default_connect_condition(),
+          init.completion_handler)(boost::system::error_code(), 1);
 
   return init.result.get();
 }
+#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol BOOST_ASIO_SVC_TPARAM,
+    typename Iterator, typename IteratorConnectHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (boost::system::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end,
-    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+    BOOST_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.
-  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (boost::system::error_code, Iterator)> init(
-      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (boost::system::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG, Iterator,
     detail::default_connect_condition, BOOST_ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
-        begin, end, detail::default_connect_condition(), init.handler)(
+      IteratorConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, end, detail::default_connect_condition(),
+          init.completion_handler)(boost::system::error_code(), 1);
+
+  return init.result.get();
+}
+
+template <typename Protocol BOOST_ASIO_SVC_TPARAM, typename EndpointSequence,
+    typename ConnectCondition, typename RangeConnectHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,
+    void (boost::system::error_code, typename Protocol::endpoint))
+async_connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
+    const EndpointSequence& endpoints, ConnectCondition connect_condition,
+    BOOST_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.
+  BOOST_ASIO_RANGE_CONNECT_HANDLER_CHECK(
+      RangeConnectHandler, handler, typename Protocol::endpoint) type_check;
+
+  async_completion<RangeConnectHandler,
+    void (boost::system::error_code, typename Protocol::endpoint)>
+      init(handler);
+
+  detail::range_connect_op<Protocol BOOST_ASIO_SVC_TARG, EndpointSequence,
+    ConnectCondition, BOOST_ASIO_HANDLER_TYPE(RangeConnectHandler,
+      void (boost::system::error_code, typename Protocol::endpoint))>(s,
+        endpoints, connect_condition, init.completion_handler)(
           boost::system::error_code(), 1);
 
   return init.result.get();
 }
 
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+#if !defined(BOOST_ASIO_NO_DEPRECATED)
+template <typename Protocol BOOST_ASIO_SVC_TPARAM, typename Iterator,
+    typename ConnectCondition, typename IteratorConnectHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (boost::system::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+    BOOST_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.
-  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (boost::system::error_code, Iterator)> init(
-      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (boost::system::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG, Iterator,
     ConnectCondition, BOOST_ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
-        begin, Iterator(), connect_condition, init.handler)(
+      IteratorConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, Iterator(), connect_condition, init.completion_handler)(
           boost::system::error_code(), 1);
 
   return init.result.get();
 }
+#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-inline BOOST_ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
+template <typename Protocol BOOST_ASIO_SVC_TPARAM, typename Iterator,
+    typename ConnectCondition, typename IteratorConnectHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,
     void (boost::system::error_code, Iterator))
-async_connect(basic_socket<Protocol, SocketService>& s,
+async_connect(basic_socket<Protocol BOOST_ASIO_SVC_TARG>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+    BOOST_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.
-  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
-      ComposedConnectHandler, handler, Iterator) type_check;
+  // not meet the documented type requirements for a IteratorConnectHandler.
+  BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
+      IteratorConnectHandler, handler, Iterator) type_check;
 
-  detail::async_result_init<ComposedConnectHandler,
-    void (boost::system::error_code, Iterator)> init(
-      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler));
+  async_completion<IteratorConnectHandler,
+    void (boost::system::error_code, Iterator)> init(handler);
 
-  detail::connect_op<Protocol, SocketService, Iterator,
+  detail::iterator_connect_op<Protocol BOOST_ASIO_SVC_TARG, Iterator,
     ConnectCondition, BOOST_ASIO_HANDLER_TYPE(
-      ComposedConnectHandler, void (boost::system::error_code, Iterator))>(s,
-        begin, end, connect_condition, init.handler)(
+      IteratorConnectHandler, void (boost::system::error_code, Iterator))>(s,
+        begin, end, connect_condition, init.completion_handler)(
           boost::system::error_code(), 1);
 
   return init.result.get();